Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Stratégier för kontexthantering hos agenter

Lektion 14 av 20 Uppdaterad 28 juli 2026 Avancerad
På denna sida
  1. Utmaningen med kontext för agenter
  2. Ett minne i tre nivåer
  3. Att tämja verktygsresultat
  4. När flera agenter arbetar tillsammans
  5. Viktiga punkter

Utmaningen med kontext för agenter

En autonom agent kedjar ihop dussintals API-anrop: den resonerar, använder verktyg, läser resultat och itererar. Vid varje steg växer kontexten. Skillnaden jämfört med en vanlig konversation är att denna tillväxt inte kommer från användaren utan från agenten själv: en SQL-fråga som returnerar trehundra rader, en hel webbsida som hämtas eller en komplett loggfil som läses. Utan en hanteringsstrategi når agenten kontextgränsen inom några få iterationer, ofta innan den hunnit avsluta uppgiften du tilldelat den.

Att designa en agent som hanterar sitt minne effektivt handlar därför om att besvara tre frågor: vad måste förbli intakt, vad kan sammanfattas och vad borde aldrig ha hamnat i kontexten från början. Vi tar itu med dem i den ordningen.

Ett minne i tre nivåer

Den struktur vi använder bygger på den klassiska uppdelningen mellan arbetsminne, episodiskt minne och semantiskt minne. Arbetsminnet håller de senaste åtgärderna i råform eftersom agenten behöver dem exakt som de är för att besluta vad den ska göra härnäst. Det episodiska minnet behåller sammanfattningar av tidigare steg: agenten vet att den utforskat ett visst spår och vad det gav, utan att behöva läsa om detaljerna. Slutligen ackumulerar det semantiska minnet fakta som fastställts en gång för alla – kund-ID, version av databasschemat, budgetbegränsningar – som aldrig får gå förlorade i en sammanfattning.

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)

Två parametrar förtjänar en diskussion innan du kopierar dem rakt av. Trunkeringen på 2 000 tecken i add_action skyddar mot utförliga verktyg, men den klipper blindt: om dina verktyg returnerar JSON får du ett ogiltigt objekt mitt i din kontext. Och max_episodes: 10 tvingar fram en begränsad glömska – vid den elfte sammanfattningen försvinner den första. För en agent som körs under lång tid bör du befordra viktiga fakta till facts innan de faller ur det episodiska fönstret, annars förlorar du dem permanent.

Att tämja verktygsresultat

Verktyg returnerar ofta skrymmande resultat: webbsidor, SQL-resultat, filinnehåll. Detta är den absolut vanligaste orsaken till kontextmättnad för en agent, och det är också det lättaste att åtgärda eftersom du hanterar det vid inmatningen snarare än i efterhand.

Funktionen nedan erbjuder tre trunkeringsstrategier. Läget start passar dokument där det väsentliga finns högst upp, som en artikel eller rapport. Läget start_end fungerar när slutet bär på den avgörande informationen: en exekveringsspårning där felet visas sist, en loggfil eller ett paginerat svar där totalen finns på slutet. Läget summary kostar ett extra API-anrop, vilket bara är motiverat för långt innehåll som verkligen är användbart för resten av resonemanget.

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]

Tabellresultat kräver särskild hantering. Att klippa en SQL-tabell mitt i tar bort rubriken eller förvränger känslan av volym: agenten ser tjugo rader och drar slutsatsen att tabellen bara innehåller tjugo. Filtret nedan behåller rubriken, ett urval från början och slutet, och – detta är nyckelpunkten – anger explicit antalet utelämnade rader och totalen. Agenten vet då att den tittar på ett utdrag och kan besluta sig för att köra en aggregatfråga istället för att resonera kring ett urval.

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

När flera agenter arbetar tillsammans

När flera underagenter arbetar parallellt är frestelsen stor att ge dem alla hela kontexten, bara för att vara på den säkra sidan. Det är det bästa sättet att multiplicera din faktura med antalet agenter samtidigt som du försämrar deras prestanda, eftersom en rörig kontext gör modellen mindre precis i sin egen uppgift. Dela istället minimal kontext: det övergripande målet så att agenten förstår vad den bidrar till, dess egen roll, gemensamma begränsningar och ett begränsat utdrag av resultat som producerats av dess kollegor.

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

Gränsen på 200 tecken per delresultat speglar en avsikt: en underagent behöver veta vad andra har hittat, inte hur de hittade det. Om dina agenter behöver hela detaljrikedomen i närliggande resultat bör du sannolikt tänka om hur du har delat upp rollerna.

Viktiga punkter

  • Strukturera agentens minne i tre nivåer: arbetsminne, episodiskt minne, semantiskt minne
  • Kompaktera automatiskt när arbetsminnet överskrider tröskeln
  • Trunkera verktygsresultat innan de injiceras i kontexten
  • Signalera alltid att ett resultat har trunkerats, och i vilken utsträckning
  • För flergentsystem, dela minimal kontext som är målinriktad efter roll