Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Spremenljivke konteksta in pomnilnik agenta

Lekcija 13 od 25 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Spremenljivke konteksta in pomnilnik agenta
  2. Spremenljivke konteksta: Skupno stanje
  3. Dinamična navodila
  4. Večzaporedni pogovorni pomnilnik
  5. Vzorec: Trajni pomnilnik z bazo podatkov
  6. Kontekst proti navodilom: Kdaj uporabiti kaj
  7. Ključne ugotovitve

Spremenljivke konteksta in pomnilnik agenta

Agent brez pomnilnika pozabi vse med posameznimi izvajanji: pri vsakem sporočilu znova vpraša po imenu stranke in vsakič začne znova. To težavo rešita dva dopolnjujoča mehanizma. Spremenljivke konteksta vbrizgajo skupno stanje v agenta in njegova orodja, medtem ko pogovorni pomnilnik ohranja nit večzaporednega pogovora.

Spremenljivke konteksta: Skupno stanje

RunContextWrapper je tipiziran objekt, ki kroži med agentom, njegovimi orodji in varovalkami. Konkretno definiraš podatkovni razred (dataclass), ki opisuje sejo – identiteto, košarico, nastavitve – in vsako orodje ga prejme kot prvi parameter. V spodnjem primeru ajouter_au_panier piše v ta objekt, voir_panier pa ga bere nazaj: obe orodji si delita isti košarico, ne da bi kakršni koli podatki potovali skozi poziv (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}")

Kontekst je spremenljiv: orodja ga lahko spreminjajo in spremembe ostanejo ohranjene tudi po izvršitvi. Zaradi tega je zadnja vrstica zanimiva – po klicu run_sync tvoj aplikacijski objekt session dejansko vsebuje oba artikla, pripravljena za pošiljanje v tvoj sistem za naročila.

Dinamična navodila

To stanje ni namenjeno le orodjem; lahko oblikuje tudi vedenje agenta. Navodila so lahko funkcija, ki prejme kontekst in sproti gradi sistemski poziv, vključno z imenom stranke in želenim jezikom.

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

Navodila se ovrednotijo ob vsakem koraku zanke agenta, kar omogoča personalizacijo v realnem času: če je orodje pravkar dodalo artikel, naslednji korak to takoj upošteva v sistemskem pozivu.

Večzaporedni pogovorni pomnilnik

Kontekst prenaša podatke, ne samega dialoga. Za vzdrževanje pogovora skozi več izmenjav moraš posredovati zgodovino. Načelo se свaja na tri korake: dodaš uporabnikovo sporočilo, zaženeš agenta s celotnim seznamom, nato pa svojo zgodovino nadomestiš s tisto, ki jo vrne rezultat – vključno s sporočili, klici orodij in odgovori.

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

Ta pomnilnik živi v RAM-u. Izgine, ko ponovno uvedeš svojo storitev, in neskončno raste, če pogovor traja: dve omejitvi, na kateri moraš pomisliti pred prehodom v proizvodno okolje.

Vzorec: Trajni pomnilnik z bazo podatkov

Za pomnilnik, ki preživi ponovne zagonе, shrani zgodovino v bazo podatkov. Tu predstavljeni pristop gre korak dlje: namesto da bi hranili vse, se agent sam odloči, kaj je vredno ohraniti, in to preko para orodij za shranjevanje in pridobivanje. Stranka reče „Sem alergičen na arašide”, agent pokliče sauvegarder_note in informacija ostane na voljo tudi tri tedne kasneje.

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 proti navodilom: Kdaj uporabiti kaj

Ti štirje mehanizmi se delno prekrivajo, klasična napaka pa je usmerjanje vsega skozi navodila. Spodnja tabela povzema preslikavo, ki si jo moraš zapomniti.

PotrebaRešitev
Uporabniški podatki (ime, vloga)Spremenljivke konteksta
Vedenje agentaNavodila (statična ali dinamična)
Zgodovina pogovoraresult.to_input_list()
Dolgoročni pomnilnikOrodja + baza podatkov
Konfiguracija med izvajanjemSpremenljivke konteksta

Ključne ugotovitve

  • RunContextWrapper prenaša tipizirano stanje, dostopno vsem orodjem
  • Kontekst je spremenljiv: orodja ga lahko med izvajanjem spreminjajo
  • Dinamična navodila (funkcije) se prilagajajo kontekstu ob vsakem koraku
  • Pogovorna zgodovina se vzdržuje z result.to_input_list()
  • Za trajni pomnilnik združi orodja za shranjevanje z bazo podatkov