Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Strategije konteksta za agente

Lekcija 14 od 20 Posodobljeno 28. julij 2026 Napredni
Na tej strani
  1. Izziv konteksta za agente
  2. Tristopenjski spomin
  3. Ukrotenje rezultatov orodij
  4. Ko sodeluje več agentov
  5. Ključne ugotovitve

Izziv konteksta za agente

Avtonomni agent zaporedno izvaja desetine klicev API-jev: razmišlja, uporablja orodja, bere rezultate in ponavlja postopke. Ob vsakem koraku se kontekst povečuje. Razlika v primerjavi z običajnim pogovorom je v tem, da te rasti ne povzroča uporabnik, temveč sam agent: poizvedba SQL, ki vrne tristo vrstic, pridobljena celotna spletna stran ali prebran celoten dnevniški zapis. Brez strategije upravljanja agent hitro doseže omejitev konteksta, pogosto že preden zaključi nalogo, ki si mu jo dodelil.

Načrtovanje agenta, ki učinkovito upravlja svoj spomin, se torej свaja na odgovore na tri vprašanja: kaj mora ostati nespremenjeno, kaj lahko povzamemo in kaj sploh ne bi smelo vstopiti v kontekst. Obravnavali jih bomo prav v tem vrstnem redu.

Tristopenjski spomin

Struktura, ki jo uporabljamo, temelji na klasični razliki med delovnim spominom, epizodnim spominom in semantičnim spominom. Delovni spomin hrani najnovejše dejanja v surovi obliki, saj jih agent potrebuje točno takšne, kot so, da se lahko odloči za naslednji korak. Epizodni spomin hrani povzetke preteklih korakov: agent ve, da je raziskal določeno sled in kaj je to prineslo, ne da bi znova bral podrobnosti. Nazadnje, semantični spomin kopiči dejstva, ugotovljena enkrat za vselej – ID stranke, različico sheme podatkovne zbirke, proračunsko omejitev – ki se nikoli ne smejo izgubiti v povzetku.

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)

Dva parametra si zaslužita razpravo, preden ju kopiraš takšna, kot sta. Omejitev na 2000 znakov v metodi add_action ščiti pred zgovornimi orodji, vendar reže slepo: če tvoja orodja vračajo JSON, boš v sredini svojega konteksta dobil neveljaven objekt. Parameter max_episodes: 10 pa vsiljuje omejeno amnezijo – ob enajstem povzetku prvi izgine. Pri agentu, ki teče dolgo časa, pomembna dejstva predčasno premakni v facts, preden izpadejo iz epizodnega okna, sicer jih boš trajno izgubil.

Ukrotenje rezultatov orodij

Orodja pogosto vračajo obsežne rezultate: spletne strani, rezultate SQL, vsebine datotek. To je daleč najpogostejši vzrok zasičenja konteksta pri agentu, hkrati pa tudi najlažje popravljivo, saj to obravnavaš ob vnosu in ne naknadno.

Spodnja funkcija ponuja tri strategije krajšanja. Način start ustreza dokumentom, kjer je bistvo na vrhu, kot sta članek ali poročilo. Način start_end deluje, ko konec nosi odločilne informacije: sled izvajanja, kjer se napaka pojavi nazadnje, dnevniška datoteka ali paginiran odgovor, kjer je skupno število navedeno na koncu. Način summary stane dodaten klic API-ja, kar je upravičeno le za dolgo vsebino, ki je resnično uporabna za preostanek razmišljanja.

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]

Tabelarični rezultati zahtevajo posebno obravnavo. Rezanje tabele SQL na sredini odstrani glavo ali izkrivlja občutek obsega: agent vidi dvajset vrstic in sklepa, da tabela vsebuje le dvajset. Spodnji filter ohrani glavo, vzorec z vrha in dna ter – kar je ključno – izrecno navede število izpuščenih vrstic in skupno število. Agent tako ve, da gleda izsek, in se lahko odloči za zagon agregatne poizvedbe namesto sklepanja na podlagi vzorca.

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"
    )

Ko sodeluje več agentov

Ko več podagentov deluje vzporedno, je skušnava, da jim vsem dodeliš celoten kontekst, zgolj zaradi varnosti. To je najboljši način, da svoj račun pomnožiš s številom agentov in hkrati poslabšaš njihovo zmogljivost, saj neurejen kontekst model naredi manj natančnega pri njegovi lastni nalogi. Namesto tega deli minimalni kontekst: globalni cilj, da agent razume, čemu prispeva, njegovo lastno vlogo, skupne omejitve in omejen izsek rezultatov, ki so jih proizvedli njegovi kolegi.

@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()
            )
        )

Omejitev na 200 znakov na delni rezultat odraža namen: podagent mora vedeti, kaj so drugi našli, ne kako so to našli. Če tvoji agenti potrebujejo vse podrobnosti sosednjih rezultatov, verjetno potrebuješ premislek o tem, kako si razdelil vloge.

Ključne ugotovitve

  • Strukturiraj spomin agenta na tri ravni: delovno, epizodno in semantično
  • Samodejno stisni podatke, ko delovni spomin preseže prag
  • Okrajšaj rezultate orodij, preden jih vstaviš v kontekst
  • Vedno signaliziraj, da je bil rezultat okrajšan, in navedi, za koliko
  • Pri nastavitvah z več agenti deli minimalni kontekst, ciljno usmerjen glede na vlogo