Strategie kontextu pro agenty
Na této stránce
Výzva kontextu pro agenty
Autonomní agent řetězí desítky volání API: uvažuje, používá nástroje, čte výsledky a iteruje. S každým krokem roste kontext. Rozdíl oproti běžné konverzaci spočívá v tom, že tento růst nezpůsobuje uživatel, ale samotný agent: dotaz SQL vracející tři sta řádků, stažená celá webová stránka nebo přečtený celý soubor s logy. Bez strategie správy narazí agent na limit kontextu během několika iterací, často ještě před dokončením úkolu, který jsi mu zadal.
Návrh agenta, který efektivně spravuje svou paměť, se tedy redukuje na odpověď na tři otázky: co musí zůstat nedotčeno, co lze shrnout a co se do kontextu vůbec nemělo dostat. Budeme je řešit právě v tomto pořadí.
Tříúrovňová paměť
Struktura, kterou používáme, vychází z klasického rozlišení mezi pracovní pamětí, epizodickou pamětí a sémantickou pamětí. Pracovní paměť uchovává nejnovější akce v surové podobě, protože je agent potřebuje přesně takové, jaké jsou, aby se rozhodl, co dělat dál. Epizodická paměť uchovává shrnutí minulých kroků: agent ví, že prozkoumal určitou stopu a co to přineslo, aniž by znovu četl detaily. Nakonec sémantická paměť akumuluje fakta stanovená jednou provždy – ID zákazníka, verze schématu databáze, rozpočtové omezení – která se nesmí nikdy ztratit v shrnutí.
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)
Dva parametry si zaslouží diskusi, než je zkopíruješ tak, jak jsou. Oříznutí na 2 000 znaků v metodě add_action chrání před upovídanými nástroji, ale řeže naslepo: pokud tvoje nástroje vracejí JSON, skončíš s neplatným objektem uprostřed kontextu. A max_episodes: 10 vynucuje omezenou amnézii – při jedenáctém shrnutí první zmizí. U agenta, který běží dlouhou dobu, povyš důležité fakta do facts dříve, než vypadnou z epizodického okna, jinak je trvale ztratíš.
Krocení výsledků nástrojů
Nástroje často vracejí objemné výsledky: webové stránky, výsledky SQL, obsahy souborů. To je zdaleka hlavní příčina nasycení kontextu u agenta a zároveň je to nejsnadnější věc k opravě, protože to řešíš při ingestování, nikoliv až dodatečně.
Funkce níže nabízí tři strategie ořezávání. Režim start se hodí pro dokumenty, kde je podstata nahoře, jako je článek nebo zpráva. Režim start_end funguje, když konec nese rozhodující informace: stopa provádění, kde se chyba objeví jako poslední, soubor s logy nebo stránkovaná odpověď, kde je celkový součet na konci. Režim summary stojí jedno volání API navíc, což je oprávněné pouze u dlouhého obsahu, který je pro další uvažování skutečně užitečný.
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]
Tabulkové výsledky vyžadují speciální zacházení. Řezání SQL tabulky uprostřed odstraní hlavičku nebo zkreslí pocit z objemu: agent vidí dvacet řádků a usoudí, že tabulka obsahuje pouze dvacet. Filtr níže zachovává hlavičku, ukázku ze začátku a konce a – a to je klíčové – explicitně uvádí počet vynechaných řádků a celkový počet. Agent pak ví, že se dívá na výňatek, a může se rozhodnout spustit agregační dotaz místo uvažování nad vzorkem.
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"
)
Když spolupracuje více agentů
Když pracuje několik podagentů paralelně, pokušení dát jim všem celý kontext „pro jistotu“ je velké. To je nejlepší způsob, jak znásobit svůj účet počtem agentů a zároveň zhoršit jejich výkon, protože nepřehledný kontext činí model méně přesným pro jeho vlastní úkol. Místo toho sdílej minimální kontext: globální cíl, aby agent chápal, k čemu přispívá, jeho vlastní roli, společná omezení a omezený výňatek z výsledků vytvořených jeho kolegy.
@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()
)
)
Limit 200 znaků na částečný výsledek odráží záměr: podagent potřebuje vědět, co ostatní našli, ne jak na to přišli. Pokud tvoji agenti potřebují plné detaily sousedních výsledků, pravděpodobně potřebíš přehodnotit, jak jsi rozdělil role.
Klíčové poznatky
- Strukturovat paměť agenta do tří úrovní: pracovní, epizodická, sémantická
- Automaticky kompaktovat, když pracovní paměť překročí práh
- Ořezávat výsledky nástrojů před jejich vložením do kontextu
- Vždy signalizovat, že výsledek byl oříznut, a o kolik
- U nastavení s více agenty sdílet minimální kontext cílený podle role