Stratégii de context pentru agenți
Pe această pagină
Provocarea contextului pentru agenți
Un agent autonom înlănțuie zeci de apeluri API: raționează, utilizează instrumente, citește rezultatele și iterează. La fiecare pas, contextul crește. Diferența față de o conversație obișnuită este că această creștere nu provine de la utilizator, ci de la agentul însuși: o interogare SQL care returnează trei sute de rânduri, o pagină web integrală recuperată sau un fișier de jurnal citit în întregime. Fără o strategie de gestionare, un agent atinge limita de context în câteva iterații, adesea înainte de a finaliza sarcina pe care i-ați atribuit-o.
Proiectarea unui agent care își gestionează eficient memoria se reduce, așadar, la răspunsul la trei întrebări: ce trebuie să rămână intact, ce poate fi rezumat și ce nu ar fi trebuit să intre niciodată în context. Le vom aborda în această ordine.
O memorie pe trei niveluri
Structura pe care o utilizăm se bazează pe distincția clasică dintre memoria de lucru, memoria episodică și memoria semantică. Memoria de lucru păstrează cele mai recente acțiuni în forma lor brută, deoarece agentul are nevoie de ele exact așa cum sunt pentru a decide ce să facă în continuare. Memoria episodică păstrează rezumate ale pașilor anteriori: agentul știe că a explorat o anumită pistă și ce a rezultat din aceasta, fără a reciti detaliile. În final, memoria semantică acumulează fapte stabilite o dată pentru totdeauna—ID-ul clientului, versiunea schemei bazei de date, constrângerea bugetară—care nu trebuie niciodată pierdute într-un rezumat.
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)
Doi parametri merită discutați înainte de a-i copia ca atare. Trunchierea la 2.000 de caractere din add_action protejează împotriva instrumentelor verbose, dar taie orb: dacă instrumentele dumneavoastră returnează JSON, veți ajunge cu un obiect invalid în mijlocul contextului. Iar max_episodes: 10 impune o amnezie limitată—la al unsprezecelea rezumat, primul dispare. Pentru un agent care rulează mult timp, promovați faptele importante în facts înainte ca acestea să iasă din fereastra episodică, altfel le veți pierde definitiv.
Imblânzirea rezultatelor instrumentelor
Instrumentele returnează adesea rezultate voluminoase: pagini web, rezultate SQL, conținuturi de fișiere. Aceasta este de departe cauza principală a saturației contextului pentru un agent și este, de asemenea, cea mai ușor de remediat, deoarece o gestionați la ingestie, nu după fapt.
Funcția de mai jos oferă trei strategii de trunchiere. Modul start se potrivește documentelor unde esențialul se află la început, cum ar fi un articol sau un raport. Modul start_end funcționează atunci când sfârșitul conține informația decisivă: o urmă de execuție unde eroarea apare la final, un fișier de jurnal sau un răspuns paginat unde totalul apare la sfârșit. Modul summary costă un apel API suplimentar, ceea ce se justifică doar pentru conținuturi lungi care sunt cu adevărat utile pentru restul raționamentului.
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]
Rezultatele tabulare necesită o manipulare specială. Tăierea unui tabel SQL la mijloc elimină antetul sau distorsionează sensul volumului: agentul vede douăzeci de rânduri și concluzionează că tabelul conține doar douăzeci. Filtrul de mai jos păstrează antetul, un eșantion din început și sfârșit și—acesta este punctul cheie—indică explicit numărul de rânduri omise și totalul. Agentul știe astfel că se uită la un extras și poate decide să ruleze o interogare de agregare în loc să raționeze pe baza unui eșantion.
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"
)
Când mai mulți agenți lucrează împreună
Când mai mulți sub-agenți lucrează în paralel, tentația este de a le oferi tuturor contextul complet, doar pentru siguranță. Aceasta este cea mai bună metodă de a vă multiplica factura cu numărul de agenți, degradându-le în același timp performanța, deoarece un context aglomerat face modelul mai puțin precis în propria sa sarcină. În schimb, partajați contextul minim: obiectivul global pentru ca agentul să înțeleagă la ce contribuie, propriul său rol, constrângerile comune și un extras limitat al rezultatelor produse de colegii săi.
@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()
)
)
Limita de 200 de caractere per rezultat parțial reflectă o intenție: un sub-agent trebuie să știe ce au găsit ceilalți, nu cum au găsit. Dacă agenții dumneavoastră au nevoie de detaliile complete ale rezultatelor vecine, probabil trebuie să regândiți modul în care ați divizat rolurile.
Puncte cheie
- Structurați memoria agentului pe trei niveluri: de lucru, episodică, semantică
- Compactați automat când memoria de lucru depășește pragul
- Trunchiați rezultatele instrumentelor înainte de a le injecta în context
- Semnalizați întotdeauna că un rezultat a fost trunchiat și în ce măsură
- Pentru configurările multi-agent, partajați un context minim țintit pe rol