Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Premenné kontextu a pamäť agenta

Lekcia 13 z 25 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Premenné kontextu a pamäť agenta
  2. Premenné kontextu: Zdieľaný stav
  3. Dynamické inštrukcie
  4. Viackroková konverzačná pamäť
  5. Vzorec: Perzistentná pamäť s databázou
  6. Kontext verzus inštrukcie: Kedy použiť čo
  7. Kľúčové poznatky

Premenné kontextu a pamäť agenta

Agent bez pamäte zabúda všetko medzi jednotlivými spusteniami: pri každej správe sa pýta na meno zákazníka a pri každom kroku začína od nuly. Tento problém riešia dva doplnkové mechanizmy. Premenné kontextu vstrekujú zdieľaný stav do agenta a jeho nástrojov, zatiaľ čo konverzačná pamäť udržiava vlákno viackrokovej konverzácie.

Premenné kontextu: Zdieľaný stav

Objekt RunContextWrapper je typovaný objekt, ktorý cirkuluje medzi agentom, jeho nástrojmi a ochrannými mechanizmami (guardrails). Konkrétne definuješ dátovú triedu (dataclass), ktorá opisuje reláciu – identitu, košík, preferencie – a každý nástroj ju dostane ako prvý parameter. V nasledujúcom príklade nástroj ajouter_au_panier do tohto objektu zapisuje a voir_panier z neho číta: oba nástroje zdieľajú rovnaký košík bez toho, aby akékoľvek údaje prechádzali cez prompt.

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 meniteľný (mutable): nástroje ho môžu upravovať a zmeny pretrvávajú aj po skončení vykonávania. To robí posledný riadok zaujímavým – po volaní run_sync tvoj aplikačný objekt session skutočne obsahuje dve položky, pripravené na odoslanie do tvoje objednávkového systému.

Dynamické inštrukcie

Tento stav nie je určený len pre nástroje: môže tiež formovať správanie agenta. Inštrukcie môžu byť funkciou, ktorá prijíma kontext a zostavuje systémový prompt za behu, vrátane mena 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",
)

Inštrukcie sa vyhodnocujú pri každom kroku slučky agenta, čo umožňuje personalizáciu v reálnom čase: ak nástroj práve pridal položku, ďalší krok to okamžite zohľadní v systémovom prompte.

Viackroková konverzačná pamäť

Kontext prenáša údaje, nie samotný dialóg. Aby si udržal konverzáciu počas viacerých výmen, musíš odovzdávať históriu. Princíp sa redukuje na tri kroky: pridáš správu používateľa, spustíš agenta s celým zoznamom a následne nahradíš svoju históriu tou, ktorú vrátil výsledok – vrátane správ, volaní nástrojov a odpovedí.

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

Táto pamäť žije v operačnej pamäti (RAM). Zmizne, keď znovu nasadíš svoju službu, a ak konverzácia trvá dlho, neobmedzene rastie: dve obmedzenia, na ktoré musíš myslieť pred nasadením do produkcie.

Vzorec: Perzistentná pamäť s databázou

Pre pamäť, ktorá prežije reštarty, ulož históriu do databázy. Prístup predstavený tu ide o krok ďalej: namiesto uchovávania všetkého sa agent sám rozhodne, čo si zaslúži byť zachované, a to prostredníctvom dvojice nástrojov na uloženie a získanie. Zákazník povie „Som alergický na arašidy“, agent zavolá sauvegarder_note a informácia zostane dostupná aj o tri týždne.

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 verzus inštrukcie: Kedy použiť čo

Tieto štyri mechanizmy sa čiastočne prekrývajú a klasickou chybou je smerovať všetko cez inštrukcie. Nasledujúca tabuľka sumarizuje mapovanie, ktoré by si si mal zapamätať.

PotrebaRiešenie
Údaje používateľa (meno, rola)Premenné kontextu
Správanie agentaInštrukcie (statické alebo dynamické)
História konverzácieresult.to_input_list()
Dlhodobá pamäťNástroje + databáza
Konfigurácia počas behuPremenné kontextu

Kľúčové poznatky

  • RunContextWrapper prenáša typovaný stav dostupný všetkým nástrojom
  • Kontext je meniteľný: nástroje ho môžu počas vykonávania upravovať
  • Dynamické inštrukcie (funkcie) sa prispôsobujú kontextu pri každom kroku
  • História konverzácie sa udržiava pomocou result.to_input_list()
  • Pre perzistentnú pamäť skombinuj nástroje na ukladanie s databázou