Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Variabler for kontekst og agenthukommelse

Lektion 13 af 25 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Variabler for kontekst og agenthukommelse
  2. Kontekstvariabler: Delt tilstand
  3. Dynamiske instrukser
  4. Konversationshukommelse over flere skift
  5. Mønster: Vedvarende hukommelse med en database
  6. Kontekst kontra instrukser: Hvornår skal du bruge hvad?
  7. Vigtige pointer

Variabler for kontekst og agenthukommelse

En agent uden hukommelse glemmer alt mellem kørsler: den spørger efter kundens navn i hver besked og starter forfra ved hvert skift. To komplementære mekanismer løser dette. Kontekstvariabler injicerer delt tilstand i agenten og dens værktøjer, mens konversationshukommelse opretholder tråden i en samtale over flere skift.

Kontekstvariabler: Delt tilstand

RunContextWrapper er et typet objekt, der cirkulerer mellem agenten, dens værktøjer og dens værneregler. Konkret definerer du en dataklasse, der beskriver sessionen – identitet, indkøbskurv, præferencer – og hvert værktøj modtager den som første parameter. I eksemplet nedenfor skriver ajouter_au_panier til dette objekt, og voir_panier læser det tilbage: begge værktøjer deler samme kurv uden at nogen data passerer gennem prompten.

from dataclasses import dataclass, field
from agents import Agent, Runner, RunContextWrapper, function_tool

@dataclass
class SessionUtilisateur:
    user_id: str
    nom: str
    email: str
    panier: list[dict] = field(default_factory=list)
    preferences: dict = field(default_factory=dict)

@function_tool
def ajouter_au_panier(
    ctx: RunContextWrapper[SessionUtilisateur],
    produit: str,
    quantite: int = 1,
) -> str:
    """Adds a product to the user's cart."""
    ctx.context.panier.append({"produit": produit, "quantite": quantite})
    total = len(ctx.context.panier)
    return f"{produit} (x{quantite}) added to cart. Total: {total} item(s)."

@function_tool
def voir_panier(ctx: RunContextWrapper[SessionUtilisateur]) -> str:
    """Displays the cart contents."""
    if not ctx.context.panier:
        return "Your cart is empty."
    lignes = [f"- {item['produit']} x{item['quantite']}" for item in ctx.context.panier]
    return f"Cart for {ctx.context.nom}:\n" + "\n".join(lignes)

agent = Agent(
    name="Shop Agent",
    instructions="You help customers with their shopping.",
    tools=[ajouter_au_panier, voir_panier],
    model="gpt-5.6-terra",
)

session = SessionUtilisateur(
    user_id="usr_789",
    nom="Marie Dupont",
    email="[email protected]",
)

# Context is shared across all tools
result = Runner.run_sync(agent, "Add a laptop and two mice to my cart", context=session)
print(result.final_output)
print(f"Cart after execution: {session.panier}")

Konteksten er mutabel: værktøjer kan ændre den, og ændringerne består efter udførelsen. Det er netop det, der gør den sidste linje interessant – efter run_sync indeholder din applikations session-objekt faktisk de to varer, klar til at blive sendt til dit ordresystem.

Dynamiske instrukser

Denne tilstand er ikke kun til værktøjer: den kan også forme agentens adfærd. Instrukser kan være en funktion, der modtager konteksten og bygger system-prompten på farten, herunder kundens navn og foretrukne sprog.

def instructions_dynamiques(ctx: RunContextWrapper[SessionUtilisateur]) -> str:
    prefs = ctx.context.preferences
    langue = prefs.get("langue", "français")
    return f"""You are a sales assistant.
    The customer's name is {ctx.context.nom}.
    Their email is {ctx.context.email}.
    They have {len(ctx.context.panier)} item(s) in their cart.
    Communicate in {langue}."""

agent = Agent(
    name="Personalized Agent",
    instructions=instructions_dynamiques,
    tools=[ajouter_au_panier, voir_panier],
    model="gpt-5.6-terra",
)

Instrukser evalueres ved hvert skift i agentens løkke, hvilket muliggør personalisering i realtid: hvis et værktøj lige har tilføjet en vare, tager næste skift straks højde for det i system-prompten.

Konversationshukommelse over flere skift

Kontekst bærer data, ikke selve dialogen. For at opretholde en samtale over flere udvekslinger skal du videregive historikken. Princippet reduceres til tre trin: du tilføjer brugerens besked, du kører agenten på den fulde liste, og derefter erstatter du din historik med den, som resultatet returnerer – inklusive beskeder, værktøjskald og svar.

from agents import Agent, Runner

agent = Agent(
    name="Assistant",
    instructions="You are an assistant that remembers the conversation.",
    model="gpt-5.6-terra",
)

historique = []

async def converser(message_utilisateur: str) -> str:
    # Add the user's message to the history
    historique.append({"role": "user", "content": message_utilisateur})

    # Run the agent with the full history
    result = await Runner.run(agent, historique)

    # Save new exchanges for the next turn
    historique.clear()
    historique.extend(result.to_input_list())

    return result.final_output

# Simulate a conversation
async def demo():
    print(await converser("My name is Thomas."))
    print(await converser("What is my first name?"))  # The agent remembers
    print(await converser("Recommend a good restaurant in Paris."))

Denne hukommelse lever i RAM. Den forsvinder, når du genudfører din tjeneste, og den vokser ubegrænset, hvis samtalen varer længe: to begrænsninger, du skal have i tankerne, før du går i produktion.

Mønster: Vedvarende hukommelse med en database

For hukommelse, der overlever genstarter, skal du gemme historikken i en database. Fremgangsmåden, der præsenteres her, går et skridt videre: i stedet for at beholde alt, beslutter agenten selv, hvad der fortjener at blive beholdt, via et par værktøjer til at gemme og hente. Kunden siger „Jeg er allergisk over for jordnødder”, agenten kalder sauvegarder_note, og oplysningen forbliver tilgængelig tre uger senere.

import json
from agents import Agent, Runner, function_tool

@function_tool
async def sauvegarder_note(ctx: RunContextWrapper, cle: str, valeur: str) -> str:
    """Saves information to remember later."""
    # In production: write to database
    notes = ctx.context.notes
    notes[cle] = valeur
    return f"Note saved: {cle} = {valeur}"

@function_tool
async def recuperer_note(ctx: RunContextWrapper, cle: str) -> str:
    """Retrieves previously saved information."""
    notes = ctx.context.notes
    valeur = notes.get(cle)
    if valeur:
        return f"{cle} = {valeur}"
    return f"No note found for '{cle}'"

@dataclass
class ContexteMemoire:
    user_id: str
    notes: dict = field(default_factory=dict)

agent = Agent(
    name="Assistant with Memory",
    instructions="""You are an assistant with persistent memory.
    Use sauvegarder_note to retain important information
    and recuperer_note to retrieve it.""",
    tools=[sauvegarder_note, recuperer_note],
    model="gpt-5.6-terra",
)

Kontekst kontra instrukser: Hvornår skal du bruge hvad?

Disse fire mekanismer overlapper delvist, og den klassiske fejl er at rute alt gennem instrukser. Tabellen nedenfor opsummerer mappingen, du skal huske.

BehovLøsning
Brugerdata (navn, rolle)Kontekstvariabler
AgentadfærdInstrukser (statisk eller dynamisk)
Konversationshistorikresult.to_input_list()
LangtidshukommelseVærktøjer + database
Konfiguration under kørselKontekstvariabler

Vigtige pointer

  • RunContextWrapper bærer typet tilstand, som alle værktøjer kan tilgå
  • Kontekst er mutabel: værktøjer kan ændre den under udførelse
  • Dynamiske instrukser (funktioner) tilpasser sig konteksten ved hvert skift
  • Konversationshistorik opretholdes med result.to_input_list()
  • Til vedvarende hukommelse kombinerer du gemme-værktøjer med en database