Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Proměnné kontextu a paměť agenta

Lekce 13 z 25 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Proměnné kontextu a paměť agenta
  2. Proměnné kontextu: Sdílený stav
  3. Dynamické instrukce
  4. Vícekolová konverzační paměť
  5. Vzorec: Perzistentní paměť s databází
  6. Kontext versus instrukce: Kdy použít co
  7. Klíčové poznatky

Proměnné kontextu a paměť agenta

Agent bez paměti zapomene vše mezi jednotlivými spuštěními: v každé zprávě se ptá na jméno zákazníka a při každém kroku začíná od nuly. Tento problém řeší dva doplňkové mechanismy. Proměnné kontextu vkládají sdílený stav do agenta a jeho nástrojů, zatímco konverzační paměť udržuje vlákno vícekolové konverzace.

Proměnné kontextu: Sdílený stav

RunContextWrapper je typovaný objekt, který cirkuluje mezi agentem, jeho nástroji a ochrannými mechanismy (guardrails). Konkrétně definuješ datovou třídu (dataclass) popisující relaci – identitu, košík, preference – a každý nástroj ji obdrží jako první parametr. V níže uvedeném příkladu ajouter_au_panier do tohoto objektu zapisuje a voir_panier z něj čte zpět: oba nástroje sdílejí stejný košík, aniž by jakákoli data procházela promptem.

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

Kontext je proměnný (mutable): nástroje jej mohou upravovat a změny přetrvávají i po dokončení executace. To je důvod, proč je poslední řádek zajímavý – po volání run_sync skutečně obsahuje tvůj aplikační objekt session dvě položky připravené k odeslání do tvého objednávkového systému.

Dynamické instrukce

Tento stav není určen pouze pro nástroje; může také formovat chování agenta. Instrukce mohou být funkcí, která přijímá kontext a za běhu sestavuje systémový prompt, včetně jména zákazníka a preferovaného jazyka.

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

Instrukce se vyhodnocují v každém kole smyčky agenta, což umožňuje personalizaci v reálném čase: pokud nástroj právě přidal položku, další okamžitě tuto změnu zohlední v systémovém promptu.

Vícekolová konverzační paměť

Kontext přenáší data, nikoli však samotný dialog. Aby byla konverzace udržována přes více výměn, musíš předávat historii. Princip se redukuje na tři kroky: přidáš zprávu uživatele, spustíš agenta s úplným seznamem a následně nahradíš svou historii tím, co vrátil výsledek – včetně zpráv, volání nástrojů a odpovědí.

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

Tato paměť žije v operační paměti (RAM). Zmizí při opětovném nasazení služby a neomezeně roste, pokud konverzace trvá dlouho: dvě omezení, na která musíš myslet před nasazením do produkce.

Vzorec: Perzistentní paměť s databází

Pro paměť, která přežije restarty, ulož historii do databáze. Zde prezentovaný přístup jde o krok dále: místo uchovávání všeho se agent sám rozhodne, co si zaslouží být zachováno, a to prostřednictvím dvojice nástrojů pro uložení a načtení. Zákazník řekne „Jsem alergický na arašídy“, agent zavolá sauvegarder_note a informace zůstane dostupná i o tři týdny později.

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

Kontext versus instrukce: Kdy použít co

Tyto čtyři mechanismy se částečně překrývají a klasickou chybou je směrovat vše přes instrukce. Níže uvedená tabulka shrnuje mapování, které si musíš pamatovat.

PotřebaŘešení
Uživatelská data (jméno, role)Proměnné kontextu
Chování agentaInstrukce (statické nebo dynamické)
Historie konverzaceresult.to_input_list()
Dlouhodobá paměťNástroje + databáze
Konfigurační parametry za běhuProměnné kontextu

Klíčové poznatky

  • RunContextWrapper přenáší typovaný stav přístupný všem nástrojům
  • Kontext je proměnný: nástroje jej mohou během executace upravovat
  • Dynamické instrukce (funkce) se přizpůsobují kontextu v každém kole
  • Historie konverzace se udržuje pomocí result.to_input_list()
  • Pro perzistentní paměť zkombinuj nástroje pro ukládání s databází