Környezetkezelési stratégiák ügynökök számára
Ezen az oldalon
A környezetkezelés kihívása ügynököknél
Egy autonóm ügynök API-hívások tucatjait láncolja össze: következtet, eszközöket használ, kiolvassa az eredményeket, majd iterál. Minden lépésnél nő a környezet mérete. A különbség egy hagyományos beszélgetéshez képest az, hogy ez a növekedés nem a felhasználótól, hanem magától az ügynöktől származik: egy SQL-lekérdezés háromszáz sort ad vissza, letöltődik egy teljes weboldal, vagy beolvasásra kerül egy egész naplófájl. Kezelési stratégia nélkül az ügynök néhány iteráción belül eléri a kontextuslimitet, gyakran még azelőtt, hogy befejezné a rábízott feladatot.
Egy hatékony memóriakezeléssel rendelkező ügynök megtervezése tehát három kérdésre adott válaszon múlik: minek kell érintetlenül maradnia, mit lehet összefoglalni, és minek nem kellett volna egyáltalán bekerülnie a kontextusba. Ezeket ebben a sorrendben tárgyaljuk.
Háromszintű memória
Az általunk használt struktúra a munkamemória, az epizodikus memória és a szemantikus memória klasszikus megkülönböztetésén alapul. A munkamemória a legfrissebb műveleteket tartja nyers formájukban, mivel az ügynöknek pontosan ilyen formában van rájuk szüksége a következő lépés eldöntéséhez. Az epizodikus memória a korábbi lépések összefoglalóit őrzi: az ügynök tudja, hogy feltárt egy bizonyos nyomvonalat és mi lett az eredménye, anélkül, hogy újra elolvasná a részleteket. Végül a szemantikus memória gyűjti össze az egyszer s mindenkorra rögzített tényeket – az ügyfélazonosítót, az adatbázis-séma verzióját, a költségvetési korlátot –, amelyek sosem veszhetnek el egy összefoglalóban.
from dataclasses import dataclass, field
@dataclass
class AgentMemory:
"""Háromszintű memóriarendszer egy ügynök számára."""
# 1. szint: munkamemória (jelenlegi kontextus)
working: list[dict] = field(default_factory=list)
# 2. szint: epizodikus memória (korábbi lépések összefoglalói)
episodes: list[str] = field(default_factory=list)
# 3. szint: szemantikus memória (állandó tények)
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):
"""Egy műveletet ad a munkamemóriához."""
self.working.append({
"action": action,
"result": result[:2000], # Hosszú eredmények levágása
})
self._check_compaction()
def add_fact(self, fact: str):
"""Egy állandó tényt ad hozzá."""
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):
"""Tömöríti a munkamemóriát egy epizóddá."""
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:] # Megtartja az utolsó 2 műveletet
# Korlátozza az epizódok számát
if len(self.episodes) > self.max_episodes:
self.episodes = self.episodes[-self.max_episodes:]
def build_context(self) -> str:
"""Felépíti a teljes kontextust a következő híváshoz."""
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)
Két paramétert érdemes megvitatni, mielőtt változatlanul másolnád őket. A 2000 karakteres levágás az add_action függvényben megvéd a bőbeszédű eszközöktől, de vakon vág: ha az eszközeid JSON-t adnak vissza, érvénytelen objektumot kapsz a kontextusod közepén. A max_episodes: 10 pedig korlátozott felejtést kényszerít ki – a tizenegyedik összefoglalónál az első eltűnik. Egy hosszú ideig futó ügynök esetén emeld át a fontos tényeket a facts listába, mielőtt kiesnének az epizodikus ablakon, különben végleg elveszíted őket.
Az eszközök eredményeinek kordában tartása
Az eszközök gyakran terjedelmes eredményeket adnak vissza: weboldalakat, SQL-eredményeket, fájltartalmakat. Ez messze a legfőbb oka az ügynökök kontextustelítődésének, és egyben a legkönnyebben javítható is, mivel ezt a betáplálásnál kezeljük, nem utólag.
Az alábbi függvény három levágási stratégiát kínál. A start mód olyan dokumentumokhoz illik, ahol a lényeg az elején van, mint egy cikkben vagy jelentésben. A start_end mód akkor működik, amikor a végén található a döntő információ: egy végrehajtási nyomvonal, ahol a hiba legutoljára jelenik meg, egy naplófájl, vagy egy lapozott válasz, ahol az összegzés a végén szerepel. A summary mód egy extra API-hívásba kerül, ami csak akkor indokolt, ha a hosszú tartalom valóban hasznos a további következtetéshez.
def truncate_tool_result(
result: str,
max_tokens: int = 2000,
strategy: str = "start_end",
) -> str:
"""Levág egy eszközeredményt a kulcsfontosságú információk megőrzésével."""
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]
A táblázatos eredmények speciális kezelést igényelnek. Ha egy SQL-táblát középen vágsz ketté, elveszíted a fejlécet, vagy torzul a mennyiség érzékelése: az ügynök lát húsz sort, és arra következtet, hogy a tábla csak húsz sort tartalmaz. Az alábbi szűrő megtartja a fejlécet, egy mintát az elejéről és a végéről, és – ez a lényeg – expliciten megadja a kihagyott sorok számát és a teljes mennyiséget. Így az ügynök tudja, hogy egy részletet lát, és dönthet úgy, hogy aggregáló lekérdezést futtat a minta alapján történő következtetés helyett.
def filter_sql_result(result: str, question: str) -> str:
"""Szűri az SQL-eredményt, hogy csak a releváns részt tartsa meg."""
lines = result.strip().split("\n")
if len(lines) <= 20:
return result
# Megtartja a fejlécet és az első/utolsó sorokat
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"
)
Amikor több ügynök dolgozik együtt
Ha több alügynök dolgozik párhuzamosan, a kísértés nagy, hogy mindenkinek odaadjuk a teljes kontextust, csak a biztonság kedvéért. Ez a legjobb módszer arra, hogy az ügynökök számával szorozd meg a számládat, miközben rontod a teljesítményüket, mivel a zsúfolt kontextus miatt a modell kevésbé lesz pontos a saját feladatában. Ehelyett oszd meg a minimális kontextust: az általános célt, hogy az ügynök értse, mihez járul hozzá, a saját szerepét, az közös korlátokat, és a társai által előállított eredmények korlátozott részletét.
@dataclass
class SharedContext:
"""Alügynökök között megosztott kontextus."""
objective: str
constraints: list[str]
partial_results: dict[str, str] = field(default_factory=dict)
def context_for_sub_agent(self, role: str) -> str:
"""Célzott kontextust generál egy alügynök számára."""
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()
)
)
A részleges eredményenkénti 200 karakteres limit szándékos: egy alügynöknek tudnia kell, mit találtak a többiek, nem azt, hogyan találták meg. Ha az ügynökeidnek szükségük van a szomszédos eredmények teljes részletességére, valószínűleg újra kell gondolnod, hogyan osztottad szét a szerepeket.
Főbb megállapítások
- Strukturáld az ügynök memóriáját három szintre: munkamemória, epizodikus, szemantikus
- Automatikusan tömöríts, amikor a munkamemória túllépi a küszöböt
- Vágd le az eszközök eredményeit, mielőtt a kontextusba injektálnád őket
- Mindig jelezd, ha egy eredményt levágtak, és hogy mekkora részt
- Többügynökös beállításoknál csak a szerepkörre szabott minimális kontextust oszd meg