Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Környezetkezelési stratégiák ügynökök számára

14. lecke 20 közül Frissítve 2026. július 28. Haladó
Ezen az oldalon
  1. A környezetkezelés kihívása ügynököknél
  2. Háromszintű memória
  3. Az eszközök eredményeinek kordában tartása
  4. Amikor több ügynök dolgozik együtt
  5. Főbb megállapítások

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