Стратегии за контекст при агенти
На тази страница
Предизвикателството с контекста при агентите
Автономният агент свързва десетки API повиквания в поредица: той разсъждава, използва инструменти, чете резултати и прави итерации. При всяка стъпка контекстът нараства. Разликата спрямо обикновен разговор е, че този растеж не идва от потребителя, а от самия агент: SQL заявка, връщаща триста реда, изцяло заредена уеб страница или прочетен цял лог файл. Без стратегия за управление агентът ще достигне лимита на контекста след няколко итерации, често преди да завърши възложената му задача.
Проектирането на агент, който управлява паметта си ефективно, се свежда до отговора на три въпроса: какво трябва да остане непокътнато, какво може да бъде обобщено и какво изобщо не е трябвало да влиза в контекста. Ще ги разгледаме точно в този ред.
Тринивова памет
Използваната от нас структура се базира на класическото разграничение между работна памет, епизодична памет и семантична памет. Работната памет съдържа най-скорошните действия в суровия им вид, защото агентът се нуждае от тях точно такива, каквито са, за да реши какво да прави следващо. Епизодичната памет пази обобщения на минали стъпки: агентът знае, че е изследвал определена следа и какъв е бил резултатът, без да препрочита детайлите. Накрая, семантичната памет натрупва факти, установени веднъж завинаги – идентификатор на клиент, версия на схемата на базата данни, бюджетно ограничение – които никога не трябва да се губят в някое обобщение.
from dataclasses import dataclass, field
@dataclass
class AgentMemory:
"""Three-level memory system for an agent."""
# Level 1: working memory (current context)
working: list[dict] = field(default_factory=list)
# Level 2: episodic memory (summaries of past steps)
episodes: list[str] = field(default_factory=list)
# Level 3: semantic memory (permanent facts)
facts: list[str] = field(default_factory=list)
max_tokens_working: int = 20_000
max_episodes: int = 10
def add_action(self, action: str, result: str):
"""Adds an action to working memory."""
self.working.append({
"action": action,
"result": result[:2000], # Truncate long results
})
self._check_compaction()
def add_fact(self, fact: str):
"""Adds a permanent fact."""
if fact not in self.facts:
self.facts.append(fact)
def _check_compaction(self):
tokens = sum(
len(str(e)) // 4 for e in self.working
)
if tokens > self.max_tokens_working:
self._compact()
def _compact(self):
"""Compacts working memory into an episode."""
import openai
client = openai.OpenAI()
text = "\n".join(
f"Action: {a['action']}\nResult: {a['result']}"
for a in self.working[:-2]
)
response = client.responses.create(
model="gpt-5.6-terra",
input=(
"Summarize these agent actions in 3-5 key points. "
"Keep important facts, results, and decisions.\n\n"
f"{text}"
),
max_output_tokens=300,
)
self.episodes.append(response.output_text)
self.working = self.working[-2:] # Keep the last 2 actions
# Limit the number of episodes
if len(self.episodes) > self.max_episodes:
self.episodes = self.episodes[-self.max_episodes:]
def build_context(self) -> str:
"""Builds the full context for the next call."""
parts = []
if self.facts:
parts.append(
"Established facts:\n" + "\n".join(f"- {f}" for f in self.facts)
)
if self.episodes:
parts.append(
"Summarized history:\n" + "\n---\n".join(self.episodes)
)
if self.working:
parts.append(
"Recent actions:\n" + "\n".join(
f"- {a['action']} → {a['result'][:500]}"
for a in self.working
)
)
return "\n\n".join(parts)
Два параметъра заслужават обсъждане, преди да ги копирате както са. Съкращаването до 2000 знака в add_action предпазва от многословни инструменти, но го прави сляпо: ако инструментите Ви връщат JSON, ще се озовете с невалиден обект по средата на контекста си. А max_episodes: 10 налага ограничена амнезия – при единадесетото обобщение първото изчезва. За агент, който работи дълго време, повишавайте важните факти до ниво facts, преди да изпаднат от епизодичния прозорец, иначе ще ги загубите завинаги.
Укротяване на резултатите от инструменти
Инструментите често връщат обемисти резултати: уеб страници, SQL резултати, съдържание на файлове. Това е далеч най-честата причина за насищане на контекста при един агент и също така е най-лесното за поправяне, защото го решавате при приемането на данните, а не постфактум.
Функцията по-долу предлага три стратегии за съкращаване. Режимът start е подходящ за документи, при които същественото е в началото, като статия или доклад. Режимът start_end работи, когато краят носи решаващата информация: trace на изпълнение, където грешката се появява последна, лог файл или страничен отговор, където общият брой е в края. Режимът summary струва едно допълнително API повикване, което е оправдано само за дълго съдържание, което наистина е полезно за останалата част от разсъжденията.
def truncate_tool_result(
result: str,
max_tokens: int = 2000,
strategy: str = "start_end",
) -> str:
"""Truncates a tool result while preserving key information."""
estimated_tokens = len(result) // 4
if estimated_tokens <= max_tokens:
return result
max_chars = max_tokens * 4
match strategy:
case "start":
return result[:max_chars] + "\n[... truncated]"
case "start_end":
half = max_chars // 2
return (
result[:half]
+ "\n[... middle truncated ...]\n"
+ result[-half:]
)
case "summary":
import openai
client = openai.OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input=f"Summarize this data keeping the essentials:\n{result}",
max_output_tokens=max_tokens,
)
return response.output_text
return result[:max_chars]
Табличните резултати изискват специално третиране. Рязането на SQL таблица по средата премахва заглавния ред или изкривява усещането за обем: агентът вижда двадесет реда и заключава, че таблицата съдържа само двадесет. Филтърът по-долу запазва заглавния ред, извадка от началото и края, и – това е ключовият момент – изрично посочва броя на пропуснатите редове и общия брой. Така агентът знае, че гледа откъс, и може да реши да изпълни агрегираща заявка, вместо да разсъждава върху извадка.
def filter_sql_result(result: str, question: str) -> str:
"""Filters a SQL result to keep only what's relevant."""
lines = result.strip().split("\n")
if len(lines) <= 20:
return result
# Keep the header and first/last lines
header = lines[0]
first_lines = lines[1:6]
last_lines = lines[-5:]
return (
f"{header}\n"
+ "\n".join(first_lines)
+ f"\n[... {len(lines) - 11} lines omitted ...]\n"
+ "\n".join(last_lines)
+ f"\n\nTotal: {len(lines) - 1} rows"
)
Когато няколко агента работят заедно
Когато няколко под-агента работят паралелно, изкушението е да им дадете на всички пълен контекст, просто за сигурност. Това е най-добрият начин да умножите сметката си по броя на агентите, като същевременно влошите тяхната ефективност, тъй като претрупаният контекст прави модела по-малко прецизен в собствената му задача. Вместо това споделяйте минималния контекст: глобалната цел, за да разбере агентът към какво допринася, собствената му роля, общите ограничения и ограничен откъс от резултатите, произведени от колегите му.
@dataclass
class SharedContext:
"""Context shared between sub-agents."""
objective: str
constraints: list[str]
partial_results: dict[str, str] = field(default_factory=dict)
def context_for_sub_agent(self, role: str) -> str:
"""Generates a targeted context for a sub-agent."""
return (
f"Global objective: {self.objective}\n"
f"Your role: {role}\n"
f"Constraints: {', '.join(self.constraints)}\n"
f"Results from other agents:\n"
+ "\n".join(
f"- {k}: {v[:200]}"
for k, v in self.partial_results.items()
)
)
Лимитът от 200 знака за всеки частичен резултат отразява едно намерение: под-агентът трябва да знае какво са открили другите, а не как са го открили. Ако агентите Ви се нуждаят от пълните детайли на съседните резултати, вероятно трябва да преосмислите как сте разделили ролите.
Ключови изводи
- Структурирайте паметта на агента на три нива: работна, епизодична, семантична
- Правете автоматично компресиране, когато работната памет надхвърли прага
- Съкращавайте резултатите от инструментите, преди да ги инжектирате в контекста
- Винаги сигнализирайте, че даден резултат е съкратен, и с колко
- За настройки с множество агенти споделяйте минимален контекст, насочен според ролята