Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Mainīgie kontekstā un aģenta atmiņa

Nodarbība 13 no 25 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Mainīgie kontekstā un aģenta atmiņa
  2. Konteksta mainīgie: kopīgs stāvoklis
  3. Dinamiskas instrukcijas
  4. Daudzsoļu sarunu atmiņa
  5. Modelis: noturīga atmiņa ar datubāzi
  6. Konteksts pret instrukcijām: kad ko lietot
  7. Galvenās atziņas

Mainīgie kontekstā un aģenta atmiņa

Aģents bez atmiņas aizmirst visu starp izpildes reizēm: tas katrā ziņojumā prasa klienta vārdu un katrā solī sāk no jauna. Šo problēmu atrisina divi papildinoši mehānismi. Konteksta mainīgie ievada kopīgu stāvokli aģentā un tā rīkos, savukārt sarunu atmiņa uztur daudzsoļu sarunas pavedienu.

Konteksta mainīgie: kopīgs stāvoklis

RunContextWrapper ir tipēts objekts, kas cirkulē starp aģentu, tā rīkiem un aizsardzības slāņiem. Konkrēti, tu definē datu klasi, kas apraksta sesiju — identitāti, grozu, preferences — un katrs rīks to saņem kā pirmo parametru. Tālāk redzamajā piemērā ajouter_au_panier raksta šajā objektā, bet voir_panier to nolasī atpakaļ: abi rīki dalās vienā grozā, neizlaižot datus caur uzvedni.

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

Konteksts ir maināms: rīki to var modificēt, un izmaiņas saglabājas pēc izpildes. Tieši tāpēc pēdējā rinda ir interesanta — pēc run_sync tava lietotnes session objekts faktiski satur abas preces, gatavas nosūtīšanai uz pasūtījumu sistēmu.

Dinamiskas instrukcijas

Šis stāvoklis nav paredzēts tikai rīkiem: tas var arī veidot aģenta uzvedību. Instrukcijas var būt funkcija, kas saņem kontekstu un dinamiski ģenerē sistēmas uzvedni, iekļaujot klienta vārdu un vēlamo valodu.

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

Instrukcijas tiek novērtētas katrā aģenta cikla solī, ļaujot reāllaika personalizācijai: ja rīks tikko pievienoja preci, nākamajā solī sistēmas uzvedne to uzreiz ņem vērā.

Daudzsoļu sarunu atmiņa

Konteksts pārnēsā datus, nevis pašu dialogu. Lai uzturētu sarunu vairāku apmaiņu garumā, nodod vēsturi. Princips reducējas uz trim soļiem: tu pievieno lietotāja ziņojumu, palaid aģentu ar pilno sarakstu, pēc tam aizstāj savu vēsturi ar to, ko atgriež rezultāts — ieskaitot ziņojumus, rīku izsaukumus un atbildes.

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

Šī atmiņa dzīvo operatīvajā atmiņā. Tā pazūd, kad pārdeployē servisu, un tā bezgalīgi aug, ja saruna ievelkas: divi ierobežojumi, kas jāpatur prātā pirms došanās uz produkciju.

Modelis: noturīga atmiņa ar datubāzi

Lai atmiņa saglabātos pēc restartiem, glabā vēsturi datubāzē. Šeit piedāvātā pieeja iet soli tālāk: tā vietā, lai glabātu visu, pats aģents izlemj, kas ir pelnījis saglabāšanu, izmantojot saglabāšanas un izgūšanas rīku pāri. Klients saka „Man ir alerģija pret zemesriekstiem”, aģents izsauc sauvegarder_note, un informācija paliek pieejama arī pēc trim nedēļām.

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

Konteksts pret instrukcijām: kad ko lietot

Šie četri mehānismi daļēji pārklājas, un klasiska kļūda ir virzīt visu caur instrukcijām. Zemāk esošā tabula apkopo atbilstību, kas jāatceras.

NepieciešamībaRisinājums
Lietotāja dati (vārds, loma)Konteksta mainīgie
Aģenta uzvedībaInstrukcijas (statiskas vai dinamiskas)
Sarunu vēstureresult.to_input_list()
Ilgtermiņa atmiņaRīki + datubāze
Izpildes laika konfigurācijaKonteksta mainīgie

Galvenās atziņas

  • RunContextWrapper pārnēsā tipētu stāvokli, kas pieejams visiem rīkiem
  • Konteksts ir maināms: rīki to var modificēt izpildes laikā
  • Dinamiskas instrukcijas (funkcijas) pielāgojas kontekstam katrā solī
  • Sarunu vēsturi uztur ar result.to_input_list()
  • Noturīgai atmiņai apvieno saglabāšanas rīkus ar datubāzi