Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Kintamieji kontekste ir agento atmintis

Paskaita 13 iš 25 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Kintamieji kontekste ir agento atmintis
  2. Konteksto kintamieji: bendra būsena
  3. Dinaminės instrukcijos
  4. Daugkartinio pokalbio atmintis
  5. Šablonas: nuolatinė atmintis su duomenų baze
  6. Kontekstas prieš instrukcijas: ką ir kada naudoti
  7. Svarbiausi punktai

Kintamieji kontekste ir agento atmintis

Agentas be atminties pamiršta viską tarp paleidimų: jis kiekviename žinutėje klausia kliento vardo ir kiekvieną kartą pradeda iš naujo. Šią problemą sprendžia du papildantys mechanizmai. Konteksto kintamieji į agentą ir jo įrankius įskiepija bendrą būseną, o pokalbio atmintis palaiko daugkartinio dialogo eigą.

Konteksto kintamieji: bendra būsena

RunContextWrapper yra tipizuotas objektas, cirkuliuojantis tarp agento, jo įrankių ir apsaugos taisyklių. Konkrečiai, tu apibrėži duomenų klasę (dataclass), aprašančią sesiją – tapatybę, krepšelį, nuostatas – ir kiekvienas įrankis ją gauna kaip pirmąjį parametrą. Toliau pateiktame pavyzdyje ajouter_au_panier rašo į šį objektą, o voir_panier jį nuskaitydamas grąžina: abu įrankiai dalijasi tuo pačiu krepšeliu, nesiunčiant jokių duomenų per užklausą (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}")

Kontekstas yra keičiamas (mutable): įrankiai gali jį modifikuoti, o pakeitimai išlieka po vykdymo. Būtent tai daro paskutinę eilutę įdomia – po run_sync tavo programos session objektas iš tikrųjų turi du elementus, paruoštus siųsti į užsakymų sistemą.

Dinaminės instrukcijos

Ši būsena skirta ne tik įrankiams: ji taip pat gali formuoti agento elgesį. Instrukcijos gali būti funkcija, gaunanti kontekstą ir kurianti sistemos užklausą realiuoju laiku, įtraukiant kliento vardą ir pageidaujamą kalbą.

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

Instrukcijos įvertinamos kiekviename agento ciklo žingsnyje, leidžiant realiuoju laiku pritaikyti personalizavimą: jei įrankis ką tik pridėjo prekę, kitame žingsnyje tai iškart atsispindi sistemos užklausoje.

Daugkartinio pokalbio atmintis

Kontekstas perneša duomenis, bet ne patį dialogą. Norint išlaikyti pokalbį per kelis apsikeitimus, reikia perduoti istoriją. Principas susideda iš trijų žingsnių: pridėsi vartotojo žinutę, paleidi agentą su visu sąrašu, tada pakeiti savo istoriją ta, kurią grąžino rezultatas – įskaitant žinutes, įrankių kvietimus ir atsakymus.

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

Ši atmintis gyvena operatyviojoje atmintyje (RAM). Ji išnyksta perkeldami servisą ir neribotai auga, jei pokalbis tęsiasi: tai du apribojimai, kuriuos reikia turėti omenyje prieš diegiant į gamybinę aplinką.

Šablonas: nuolatinė atmintis su duomenų baze

Jei nori atminties, išliekančios po perkrovimų, saugok istoriją duomenų bazėje. Čia pateiktas požiūris žengia dar toliau: vietoj to, kad saugotum viską, pats agentas nusprendžia, ką verta išsaugoti, naudodamas įrankių porą „įrašyti“ ir „gauti“. Klientas sako „esu alergiškas žemės riešutams“, agentas iškviečia sauvegarder_note, ir informacija lieka prieinama net po trijų savaičių.

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

Kontekstas prieš instrukcijas: ką ir kada naudoti

Šie keturi mechanizmai iš dalies persidengia, o klasikinė klaida – viską maršrutizuoti per instrukcijas. Toliau pateiktoje lentelėje apibendrintas atitikmenų žemėlapis, kurį verta įsiminti.

PoreikisSprendimas
Vartotojo duomenys (vardas, vaidmuo)Konteksto kintamieji
Agentos elgesysInstrukcijos (statinės arba dinaminės)
Pokalbio istorijaresult.to_input_list()
Ilgalaikė atmintisĮrankiai + duomenų bazė
Vykdymo konfigūracijaKonteksto kintamieji

Svarbiausi punktai

  • RunContextWrapper perneša tipizuotą būseną, prieinamą visiems įrankiams
  • Kontekstas yra keičiamas: įrankiai gali jį modifikuoti vykdymo metu
  • Dinaminės instrukcijos (funkcijos) prisitaiko prie konteksto kiekviename žingsnyje
  • Pokalbio istorija palaikoma naudojant result.to_input_list()
  • Nuolatinei atminčiai derink įrašymo įrankius su duomenų baze