Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Muutujad kontekstis ja agendi mälu

Õppetund 13 / 25 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Muutujad kontekstis ja agendi mälu
  2. Konteksti muutujad: jagatud olek
  3. Dünaamilised juhised
  4. Mitmevooruline vestlusmälu
  5. Muster: püsiv mälu andmebaasiga
  6. Kontekst vs juhised: millal mida kasutada
  7. Peamised punktid

Muutujad kontekstis ja agendi mälu

Ilma mäluta agent unustab kõik käivituste vahel: ta küsib kliendi nime igas sõnumis ja alustab igal sammul nullist. Selle lahendavad kaks täiendavat mehhanismi. Konteksti muutujad sisestavad jagatud oleku agentile ja selle tööriistadele, samas kui vestlusmälu hoiab mitmevoorulise vestluse lõime.

Konteksti muutujad: jagatud olek

RunContextWrapper on tüübitud objekt, mis liigub agendi, selle tööriistade ja kaitsepiirangute vahel. Konkreetsemalt defineerid andmeklassi, mis kirjeldab seanssi – identiteet, ostukorv, eelistused – ja iga tööriist saab selle esimese parameetrina. Allpool toodud näites kirjutab ajouter_au_panier sellesse objekti ja voir_panier loeb selle tagasi: mõlemad tööriistad jagavad sama ostukorvi, ilma et andmed läbiksid vihjet.

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

Kontekst on muudetav: tööriistad saavad seda muuta ja muudatused püsivad pärast täitmist. See teeb viimase rea huvitavaks – pärast run_sync sisaldab sinu rakenduse session objekt tegelikult kahte eset, valmis saatmiseks tellimussüsteemi.

Dünaamilised juhised

See olek ei ole mõeldud ainult tööriistadele: see võib kujundada ka agendi käitumist. Juhised võivad olla funktsioon, mis saab konteksti ja koostab süsteemse vihje reaalajas, kaasates kliendi nime ja eelistatud keele.

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

Juhiseid hinnatakse agendi tsükli igal voorul, võimaldades reaalajas isikupärastamist: kui tööriist lisas just eseme, võtab järgmine voor seda süsteemses vihjes kohe arvesse.

Mitmevooruline vestlusmälu

Kontekst kannab andmeid, mitte dialoogi ennast. Vestluse säilitamiseks üle mitme vahetuse edasta ajalugu. Põhimõte taandub kolmele sammule: lisad kasutaja sõnumi, käivitad agendi kogu loendiga ja asendad oma ajaloo tulemuse tagastatuga – kaasates sõnumid, tööriistakutsed ja vastused.

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

See mälu elab RAM-is. See kaob teenuse uuesti kasutuselevõtul ja kasvab lõpmatult, kui vestlus kestab: kaks piirangut, mida enne tootmisse minekut silmas pidada.

Muster: püsiv mälu andmebaasiga

Mälu jaoks, mis jääb taaskäivitustest ellu, salvesta ajalugu andmebaasi. Siin esitatud lähenemine läheb sammu võrra kaugemale: selle asemel, et kõike hoida, otsustab agent ise, mida tasub säilitada, salvestamise ja taastamise tööriistade paari kaudu. Klient ütleb „Olen maapähklite suhtes allergiline“, agent kutsub sauvegarder_note ja teave jääb kolm nädalat hiljem kättesaadavaks.

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 vs juhised: millal mida kasutada

Need neli mehhanismi kattuvad osaliselt ja klassikaline viga on suunata kõik juhiste kaudu. Allpool olev tabel võtab kokku meelespeetava vastavuse.

VajadusLahendus
Kasutajaandmed (nimi, roll)Konteksti muutujad
Agendi käitumineJuhised (staatilised või dünaamilised)
Vestluse ajaluguresult.to_input_list()
Pikaajaline mäluTööriistad + andmebaas
Käitusaegne konfiguratsioonKonteksti muutujad

Peamised punktid

  • RunContextWrapper kannab tüübitud olekut, millele pääsevad ligi kõik tööriistad
  • Kontekst on muudetav: tööriistad saavad seda täitmise ajal muuta
  • Dünaamilised juhised (funktsioonid) kohanduvad kontekstiga igal voorul
  • Vestluse ajalugu hoitakse result.to_input_list() abil
  • Püsiva mälu jaoks kombineeri salvestamise tööriistad andmebaasiga