Stratégijos kontekstui valdyti agentuose
Šiame puslapyje
Konteksto iššūkis agentams
Autonominis agentas sujungia dešimtis API užklausų: jis samprotauja, naudoja įrankius, skaito rezultatus ir kartojasi. Kiekviename žingsnyje kontekstas auga. Skirtumas nuo įprasto pokalbio tas, kad šis augimas kyla ne iš naudotojo, o iš paties agento: SQL užklausa grąžina tris šimtus eilučių, atsisiunčiamas visas tinklalapis arba perskaitomas visas žurnalo failas. Be valdymo strategijos, agentas pasiekia konteksto ribą po kelių iteracijų, dažnai dar prieš baigdamas jam pavestą užduotį.
Todėl kuriant agentą, kuris efektyviai valdo savo atmintį, reikia atsakyti į tris klausimus: kas turi likti nepakitusi, ką galima apibendrinti ir kas iš viso neturėjo patekti į kontekstą. Nagrinėsime juos tokia tvarka.
Trijų lygių atmintis
Naudojama struktūra remiasi klasikiniu skirtumu tarp darbinės atminties, epizodinės atminties ir semantinės atminties. Darbinė atmintis saugo naujausius veiksmus jų pirminėje formoje, nes agentui jų reikia tiksliai tokių, kokie jie yra, norint nuspręsti, ką daryti toliau. Epizodinė atmintis saugo praeities žingsnių santraukas: agentas žino, kad ištyrė tam tikrą kryptį ir ką tai davė, neskaitant detalių iš naujo. Galiausiai semantinė atmintis kaupia kartą ir visiems laikams nustatytus faktus – kliento ID, duomenų bazės schemos versiją, biudžeto apribojimą – kurie niekada neturi pasimesti santraukoje.
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)
Prieš nukopijuodamas šiuos parametrus kaip yra, verta juos aptarti. 2000 simbolių apkarpymas funkcijoje add_action apsaugo nuo išsamiai išsiplečiančių įrankių, tačiau tai daroma aklai: jei tavo įrankiai grąžina JSON, konteksto viduryje gali atsidurti negaliojantis objektas. O max_episodes: 10 užtikrina ribotą amneziją – vienuoliktos santraukos metu pirmoji išnyksta. Ilgai veikiančiam agentui svarbius faktus prieš jiems iškrentant iš epizodinio lango perkelti į facts, kitaip juos prarasi visam laikui.
Įrankių rezultatų suvaldymas
Įrankiai dažnai grąžina didelius rezultatus: tinklalapius, SQL rezultatus, failų turinį. Tai yra pagrindinė konteksto prisotinimo priežastis agentams, ir tai taip pat lengviausiai išsprendžiama, nes tai tvarkoma duomenų gavimo metu, o ne po fakto.
Toliau pateikta funkcija siūlo tris apkarpymo strategijas. Režimas start tinka dokumentams, kuriuose esmė yra viršuje, pavyzdžiui, straipsniui ar ataskaitai. Režimas start_end veikia, kai lemiamą informaciją neša pabaiga: vykdymo pėdsakas, kuriame klaida atsiranda pabaigoje, žurnalo failas arba puslapiuotas atsakymas, kuriame bendra suma nurodyta gale. Režimas summary kainuoja papildomą API užklausą, kuri pateisinama tik ilgam turiniui, kuris tikrai naudingas tolesniam samprotavimui.
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]
Lenteliniai rezultatai reikalauja specialaus apdorojimo. Perlaužus SQL lentelę viduryje, pašalinama antraštė arba iškraipomas apimties suvokimas: agentas mato dvidešimt eilučių ir daro išvadą, kad lentelėje yra tik dvidešimt. Toliau pateiktas filtras palieka antraštę, imtį iš viršaus ir apačios, ir – tai svarbiausia – aiškiai nurodo praleistų eilučių skaičių bei bendrą kiekį. Tuomet agentas žino, kad žiūri į ištrauką, ir gali nuspręsti vykdyti agregacinę užklausą, o ne samprotauti remdamasis imtimi.
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"
)
Kai dirba keli agentai
Kai keli sub-agentai dirba lygiagrečiai, pagunda yra suteikti jiems visiems visą kontekstą, tik dėl saugumo. Tai geriausias būdas padauginti sąskaitą iš agentų skaičiaus ir tuo pačiu pabloginti jų našumą, nes perkrautas kontekstas daro modelį mažiau tiksliu atliekant savo užduotį. Vietoj to, dalinkis minimaliu kontekstu: bendruoju tikslu, kad agentas suprastų, prie ko jis prisideda, jo paties vaidmeniu, bendrais apribojimais ir ribota kitų agentų sukurtų rezultatų ištrauka.
@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 simbolių riba kiekvienam daliniam rezultatui atspindi ketinimą: sub-agentui reikia žinoti, ką kiti rado, o ne kaip jie tai rado. Jei tavo agentams reikia visų detalių apie gretimų agentų rezultatus, greičiausiai reikia persvarstyti, kaip padalinai vaidmenis.
Svarbiausi punktai
- Struktūrizuok agento atmintį į tris lygius: darbinę, epizodinę, semantinę
- Automatiškai glaudink, kai darbinė atmintis viršija slenkstį
- Apkarpyk įrankių rezultatus prieš įterpdamas juos į kontekstą
- Visada signalizuok, kad rezultatas buvo apkarpintas, ir nurodyk, kiek
- Kelių agentų sąrankose dalinkis minimaliu, pagal vaidmenį pritaikytu kontekstu