Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Variabelen voor context en geheugen van agents

Les 13 van 25 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Variabelen voor context en geheugen van agents
  2. Contextvariabelen: Gedeelde status
  3. Dynamische instructies
  4. Conversationeel geheugen voor meerdere beurten
  5. Patroon: Aanhoudend geheugen met een database
  6. Context versus instructies: wanneer gebruikt u wat?
  7. Belangrijkste punten

Variabelen voor context en geheugen van agents

Een agent zonder geheugen vergeet alles tussen uitvoeringen in: hij vraagt bij elk bericht om de naam van de klant en begint bij elke beurt opnieuw. Twee complementaire mechanismen lossen dit op. Contextvariabelen injecteren gedeelde status in de agent en zijn tools, terwijl conversationeel geheugen de rode draad van een gesprek met meerdere beurten bewaakt.

Contextvariabelen: Gedeelde status

De RunContextWrapper is een getypeerd object dat circuleert tussen de agent, zijn tools en zijn bewakingsmechanismen. Concreet definieert u een dataclass die de sessie beschrijft—identiteit, winkelwagen, voorkeuren—en elke tool ontvangt dit als eerste parameter. In het onderstaande voorbeeld schrijft ajouter_au_panier naar dit object en leest voir_panier het terug: beide tools delen dezelfde winkelwagen zonder dat er gegevens via de prompt worden uitgewisseld.

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

De context is wijzigbaar: tools kunnen deze aanpassen en de wijzigingen blijven behouden na uitvoering. Dit maakt de laatste regel interessant: na run_sync bevat het session-object van uw applicatie daadwerkelijk de twee items, klaar om naar uw bestelsysteem te worden verzonden.

Dynamische instructies

Deze status is niet alleen voor tools bedoeld: het kan ook het gedrag van de agent sturen. Instructies kunnen een functie zijn die de context ontvangt en de systeemprompt dynamisch opbouwt, inclusief de naam van de klant en de voorkeurstaal.

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

Instructies worden bij elke beurt van de agent-lus geëvalueerd, wat personalisatie in real-time mogelijk maakt: als een tool zojuist een item heeft toegevoegd, houdt de volgende beurt hier direct rekening mee in de systeemprompt.

Conversationeel geheugen voor meerdere beurten

Context draagt gegevens, niet de dialoog zelf. Om een gesprek over meerdere uitwisselingen heen te onderhouden, geeft u de geschiedenis door. Het principe komt neer op drie stappen: u voegt het bericht van de gebruiker toe, u laat de agent draaien op de volledige lijst, en vervolgens vervangt u uw geschiedenis door die welke door het resultaat wordt teruggegeven—inclusief berichten, tool-aanroepen en antwoorden.

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

Dit geheugen leeft in het RAM-geheugen. Het verdwijnt wanneer u uw service opnieuw implementeert, en het groeit eindeloos als het gesprek voortduurt: twee beperkingen om rekening mee te houden voordat u naar productie gaat.

Patroon: Aanhoudend geheugen met een database

Voor geheugen dat herstarts overleeft, slaat u de geschiedenis op in een database. De hier gepresenteerde aanpak gaat een stap verder: in plaats van alles te bewaren, beslist de agent zelf wat bewaard moet blijven, via een paar tools voor opslaan en ophalen. De klant zegt “Ik ben allergisch voor pinda’s”, de agent roept sauvegarder_note aan, en de informatie blijft drie weken later beschikbaar.

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

Context versus instructies: wanneer gebruikt u wat?

Deze vier mechanismen overlappen elkaar gedeeltelijk en de klassieke fout is om alles via instructies te laten lopen. De onderstaande tabel vat de mapping samen die u moet onthouden.

BehoefteOplossing
Gebruikersgegevens (naam, rol)Contextvariabelen
Gedrag van de agentInstructies (statisch of dynamisch)
Gespreksgeschiedenisresult.to_input_list()
Geheugen op lange termijnTools + database
Runtime-configuratieContextvariabelen

Belangrijkste punten

  • RunContextWrapper draagt getypeerde status die toegankelijk is voor alle tools
  • Context is wijzigbaar: tools kunnen deze tijdens uitvoering aanpassen
  • Dynamische instructies (functies) passen zich bij elke beurt aan de context aan
  • Gespreksgeschiedenis wordt onderhouden met result.to_input_list()
  • Combineer voor aanhoudend geheugen opslagtools met een database