Strateġiji tal-kuntest għall-aġenti
F'din il-paġna
L-isfida tal-kuntest għall-aġenti
Aġent awtonomu jgħaqqad flimkien għexieren ta’ sejħiet API: jirraġuna, juża għodod, jaqra r-riżultati, u jiterah. F’kull pass, il-kuntest jikber. Id-differenza minn konversazzjoni ordinarja hija li dan it-tkabbir ma jiġix mill-utent iżda mill-aġent innifsu: mistoqsija SQL li tirritorna tliet mitt ringiela, paġna web sħiħa rkuprata, jew fajl tal-log sħiħ moqri. Mingħajr strateġija ta’ ġestjoni, aġent jilħaq il-limitu tal-kuntest fi ftit iterazzjonijiet, spiss qabel ma jtemm il-kompitu li fdatlu.
Id-disinn ta’ aġent li jimmaniġġja l-memorja tiegħu b’mod effettiv għalhekk jinżel biex twieġeb tliet mistoqsijiet: x’għandu jibqa’ intatt, x’jista’ jiġi ssuntat, u x’qatt ma kellu jidħol fil-kuntest mill-bidu nett. Se nittrattawhom f’dak l-ordni.
Memorja fuq tliet livelli
L-istruttura li nużaw tibbaża fuq id-distinzjoni klassika bejn il-memorja tax-xogħol, il-memorja episodika u l-memorja semantika. Il-memorja tax-xogħol iżżomm l-aktar azzjonijiet riċenti fil-forma mhux maqlugħa tagħhom għax l-aġent jeħtieġhom eżattament kif inhuma biex jiddeċiedi x’għandu jagħmel wara. Il-memorja episodika żżomm sommarji ta’ passi preċedenti: l-aġent ikun jaf li esplora ċerta triq u x’ħarġet minnha, mingħajr ma jerġa’ jaqra d-dettalji. Fl-aħħar nett, il-memorja semantika takkumula fatti stabbiliti darba għal dejjem—l-ID tal-klijent, il-verżjoni tal-iskema tad-database, il-vinċolu tal-baġit—li qatt m’għandhom jintilfu f’sommarju.
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)
Żewġ parametri jistħoqqilhom diskussjoni qabel ma tikkopjahom hekk kif inhuma. It-trunkament ta’ 2,000 karattru f’add_action jipproteġi kontra għodod verbali, iżda jaqta’ bl-indiscriminat: jekk l-għodod tiegħek jirritornaw JSON, tispiċċa b’oġġett invalidu fin-nofs tal-kuntest tiegħek. U max_episodes: 10 jinfurza amneżija limitata: fil-ħdax-il sommarju, l-ewwel wieħed jisparixxi. Għal aġent li jopera għal żmien twil, promwovi fatti importanti għal facts qabel ma joħorġu mit-tieqa episodika, inkella titlefhom għal dejjem.
Ir-raddim tar-riżultati tal-għodod
L-għodod spiss jirritornaw riżultati voluminużi: paġni web, riżultati SQL, kontenuti ta’ fajls. Din hija bla dubju l-aktar kawża ewlenija ta’ saturazzjoni tal-kuntest għal aġent, u hija wkoll l-aktar waħda faċli biex issolviha għax tittrattaha fl-ingestjoni aktar milli wara l-fatt.
Il-funzjoni hawn taħt toffri tliet strateġiji ta’ trunkament. Il-modalità start taqbel għal dokumenti fejn l-essenzjali jinsabu fuq nett, bħal artiklu jew rapport. Il-modalità start_end taħdem meta t-tmiem iġorr l-informazzjoni deċiżiva: traċċa ta’ eżekuzzjoni fejn l-iżball jidher l-aħħar, fajl tal-log, jew tweġiba paġinata fejn it-total jidher fl-aħħar. Il-modalità summary tispiċċa b’sejħa API ekstra, li tiġġustifika ruħha biss għal kontenut twil li huwa verament utli għall-bqija tar-raġunament.
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]
Ir-riżultati tabulari jeħtieġu trattament speċjali. Li taqta’ tabella SQL fin-nofs ineħħi l-intestatura jew idgħajjef is-sens tal-volum: l-aġent jara għoxrin ringiela u jikkonkludi li t-tabella fiha biss għoxrin. Il-filtru hawn taħt iżomm l-intestatura, kampjun mill-bidu u mit-tmiem, u—dan huwa l-punt ewlieni—jiddikjara b’mod espliċitu n-numru ta’ ringieli mħassra u t-total. L-aġent imbagħad ikun jaf li qed iħares lejn estratt u jista’ jiddeċiedi li jħaddem mistoqsija aggregata aktar milli jirraġuna fuq kampjun.
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"
)
Meta diversi aġenti jaħdmu flimkien
Meta diversi sotto-aġenti jaħdmu parallell, it-tentazzjoni hija li tagħtihom ilkoll il-kuntest sħiħ, biss biex tkun żgur. Dik hija l-aħjar triqa biex timmultiplika l-kont tiegħek bin-numru ta’ aġenti filwaqt li tiddeterjora l-prestazzjoni tagħhom, peress li kuntest imħawwad jagħmel il-mudell inqas preċiż fil-kompitu tiegħu stess. Minflok, aqsam il-kuntest minimu: l-għan globali biex l-aġent jifhem għal xiex qed jikkontribwixxi, ir-rwol tiegħu stess, vinċoli komuni, u estratt limitat tar-riżultati prodotti mill-pari tiegħu.
@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()
)
)
Il-limitu ta’ 200 karattru għal kull riżultat parzjali jirrifletti intenzjoni: sotto-aġent jeħtieġ ikun jaf x’sabu l-oħrajn, mhux kif sabuh. Jekk l-aġenti tiegħek jeħtieġu d-dettall sħiħ tar-riżultati tal-ġirien, probabbilment għandek terġa’ taħseb kif qassamt ir-rwoli.
Punti Ewlenin
- Iddisinja l-memorja tal-aġent fuq tliet livelli: tax-xogħol, episodika, semantika
- Ikkompatta awtomatikament meta l-memorja tax-xogħol taqbeż il-limitu
- Aqta’ r-riżultati tal-għodod qabel ma tinjettahom fil-kuntest
- Dejjem indika li riżultat ġie maqtugħ, u kemm
- Għal setups multi-aġent, aqsam kuntest minimu mmirat skont ir-rwol