Agentide kontekstistrateegiad
Sellel lehel
Agentide kontekstiväljakutse
Autonoomne agent aheldab kokku kümneid API-kutseid: ta arutleb, kasutab tööriistu, loeb tulemusi ja kordab protsessi. Iga sammuga kasvab kontekst. Erinevus tavalisest vestlusest seisneb selles, et see kasv ei tulene kasutajast, vaid agentist endast: SQL-päring, mis tagastab kolmsada rida, terviklik veebileht või loetud logifail. Ilma haldusstrateegiata jõuab agent konteksti piiranguni mõne iteratsiooni jooksul, sageli enne, kui ta on talle usaldatud ülesande lõpetanud.
Agenti kujundamine, mis haldab oma mälu tõhusalt, taandub seega kolmele küsimusele: mis peab jääma muutumatuks, mida saab kokku võtta ja mis ei oleks tohtinud konteksti üldse sattuda. Vastame neile just selles järjekorras.
Kolmetasemeline mälu
Kasutatav struktuur põhineb klassikalisel eristusel töömälu, episoodilise mälu ja semantilise mälu vahel. Töömälu hoiab viimaseid tegevusi nende toorkujul, sest agent vajab neid täpselt sellisena, et otsustada, mida järgmiseks teha. Episoodiline mälu hoiab mineviku sammude kokkuvõtteid: agent teab, et ta uuris teatud suunda ja mida see andis, ilma et ta peaks detaile uuesti läbi lugema. Lõpuks kogub semantiline mälu fakte, mis on kord ja igaveseks kindlaks tehtud – kliendi ID, andmebaasi skeemi versioon, eelarvepiirang –, mis ei tohi kunagi kokkuvõttes kaduma minna.
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)
Kaks parameetrit väärivad arutelu enne, kui need muutmatult üle võtad. 2000-märgiline kärpimine funktsioonis add_action kaitseb ülevoolavate tööriistade eest, kuid lõikab pimesi: kui sinu tööriistad tagastavad JSON-i, lõpeb sul konteksti keskel vigane objekt. Ja max_episodes: 10 sunnib peale piiratud unustamise – üheteistkümnenda kokkuvõtte juures kaob esimene. Pikaajaliselt töötava agenti puhul vii olulised faktid enne episoodilisest aknast väljalangemist kategooriasse facts, vastasel juhul kaotad need jäädavalt.
Tööriistade tulemuste ohjeldamine
Tööriistad tagastavad sageli mahukaid tulemusi: veebilehti, SQL-tulemusi, failisisu. See on kaugelt suurim põhjus agentide konteksti küllastumisel ja samal ajal kõige lihtsamini lahendatav, sest tegeled sellega sisendietapis, mitte järelmõjudena.
Allpool olev funktsioon pakub kolme kärpimisstrateegiat. Režiim start sobib dokumentidele, kus oluline on alguses, nagu artiklid või aruanded. Režiim start_end toimib siis, kui otsustav info on lõpus: täitmise jälg, kus viga ilmub viimasena, logifail või leheküljeldatud vastus, kus kogusumma on lõpus. Režiim summary maksab ühe lisanduva API-kutse, mis on õigustatud ainult pika ja tõeliselt kasuliku sisu puhul edasiseks arutluseks.
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]
Tabelitulemused nõuavad erikäsitlust. SQL-tabeli keskel lõikamine eemaldab päise või moonutab mahu tajumist: agent näeb kakskümmend rida ja järeldab, et tabel sisaldab ainult kakskümmend rida. Allpool olev filter säilitab päise, proovi algusest ja lõpust ning – ja see on võtmepunkt – märgib sõnaselgelt vahele jäetud ridade arvu ja koguarvu. Agent teab siis, et vaatab väljavõtet, ja saab otsustada käivitada agregeeritud päringu, mitte arutleda proovi põhjal.
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"
)
Kui mitu agentit töötavad koos
Kui mitu ala-agentit töötavad paralleelselt, on kiusatus anda neile kõigile kogu kontekst, lihtsalt kindlustunde pärast. See on parim viis korrutada oma arve agentide arvuga ja halvendada nende jõudlust, sest segane kontekst muudab mudeli oma ülesandes ebatäpsemaks. Selle asemel jaga minimaalset konteksti: globaalne eesmärk, et agent mõistaks, millesse ta panustab, tema enda roll, ühised piirangud ja piiratud väljavõte tulemustest, mille on tootnud tema kaasagendid.
@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-märgiline piirang osatulemuste kohta peegeldab kavatsust: ala-agent peab teadma, mida teised leidsid, mitte kuidas nad selle leidsid. Kui sinu agendid vajavad naabertulemuste täielikke detaile, peaksid tõenäoliselt üle mõtlema, kuidas oled rollid jaotanud.
Peamised punktid
- Struktureeri agenti mälu kolmel tasemel: töö-, episoodiline, semantiline
- Tihenda automaatselt, kui töömälu ületab lävendit
- Kärbi tööriistade tulemused enne konteksti sisestamist
- Märgi alati, et tulemust on kärbitud, ja kui palju
- Mitme agenti süsteemides jaga minimaalset, rollipõhist konteksti