Kintamieji kontekste ir agento atmintis
Šiame puslapyje
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.
| Poreikis | Sprendimas |
|---|---|
| Vartotojo duomenys (vardas, vaidmuo) | Konteksto kintamieji |
| Agentos elgesys | Instrukcijos (statinės arba dinaminės) |
| Pokalbio istorija | result.to_input_list() |
| Ilgalaikė atmintis | Įrankiai + duomenų bazė |
| Vykdymo konfigūracija | Konteksto kintamieji |
Svarbiausi punktai
RunContextWrapperperneš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