Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Varjabbli tal-Kuntest u l-Memorja tal-Aġent

Lezzjoni 13 / 25 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Varjabbli tal-Kuntest u l-Memorja tal-Aġent
  2. Varjabbli tal-Kuntest: Stat Kondiviż
  3. Istruzzjonijiet Dinamiċi
  4. Memorja Konversazzjonali b’Diversi Dawriet
  5. Mudell: Memorja Persistenti b’Bażi tad-Data
  6. Kuntest vs Istruzzjonijiet: Meta Tuża X’
  7. Punti Ewlenin

Varjabbli tal-Kuntest u l-Memorja tal-Aġent

Aġent mingħajr memorja jinsa kollox bejn is-sessjonijiet: jistaqsi għal isem il-klijent f’kull messaġġ u jibda minn ebdien f’kull dawra. Żewġ mekkaniżmi komplementari jsolvu dan. Il-varjabbli tal-kuntest jidħlu stat kondiviż fl-aġent u l-għodod tiegħu, filwaqt li l-memorja konversazzjonali iżżomm il-fil ta’ konversazzjoni b’diversi dawriet.

Varjabbli tal-Kuntest: Stat Kondiviż

L-oġġett RunContextWrapper huwa oġġett ittajpjat li jiċċirkola bejn l-aġent, l-għodod tiegħu, u l-gwardjani tiegħu (guardrails). Konkretament, tiddefinixxi dataclass li tiddeskrivi s-sessjoni—identità, karrettun, preferenzi—u kull għodda tirċevih bħala l-ewwel parametru. Fl-eżempju hawn taħt, ajouter_au_panier jikteb f’dan l-oġġett u voir_panier jaqrah lura: iż-żewġ għodod jaqsmu l-istess karrettun mingħajr ebda data li tgħaddi mill-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}")

Il-kuntest huwa mutabbli: l-għodod jistgħu jimmodifikawh, u l-bidliet jibqgħu wara l-eżekuzzjoni. Dan huwa dak li jagħmel l-aħħar linja interessanti—wara run_sync, l-oġġett session tal-applikazzjoni tiegħek fih effettivament iż-żewġ oġġetti, lesti biex jintbagħtu lis-sistema tal-ordnijiet tiegħek.

Istruzzjonijiet Dinamiċi

Dan l-istat mhuwiex biss għall-għodod: jista’ jifforma wkoll l-imġiba tal-aġent. L-istruzzjonijiet jistgħu jkunu funzjoni li tirċievi l-kuntest u tibni l-prompt tas-sistema fuq it-titjira, inkluż l-isem tal-klijent u l-lingwa preferuta.

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

L-istruzzjonijiet jiġu evalwati f’kull dawra taċ-ċiklu tal-aġent, u jippermettu personalizzazzjoni f’ħin reali: jekk għodda għadha kemm żiedet oġġett, id-dawra li jmiss tqis dan immedjatament fil-prompt tas-sistema.

Memorja Konversazzjonali b’Diversi Dawriet

Il-kuntest iġorr id-data, mhux id-djalogu nnifsu. Biex iżżomm konversazzjoni fuq skambji multipli, għaddi l-istoriku. Il-prinċipju jinżel għal tliet passi: iżżid il-messaġġ tal-utent, tħaddem l-aġent fuq il-lista sħiħa, imbagħad tibdel l-istoriku tiegħek b’dak irritornat mir-riżultat—inklużi messaġġi, sejħiet tal-għodod, u tweġibiet.

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

Din il-memorja tgħix fir-RAM. Tisparixxi meta terġa’ tiddispjega s-servizz tiegħek, u tikber indefinitament jekk il-konversazzjoni ddum: żewġ limiti li għandek iżżomm f’moħħok qabel ma tmur għall-produzzjoni.

Mudell: Memorja Persistenti b’Bażi tad-Data

Għal memorja li tibqa’ ħajja wara r-ristarts, aħżen l-istoriku f’bażi tad-data. L-approċċ ippreżentat hawnhekk imur pass ‘il quddiem: minflok ma żżomm kollox, l-aġent jiddeċiedi huwa stess x’jistħoqq li jinżamm, permezz ta’ par ta’ għodod tas-salvataġġ u r-rikupru. Il-klijent jgħid “Jien allerġiku għall-karawett”, l-aġent isejjaħ sauvegarder_note, u l-informazzjoni tibqa’ disponibbli tliet ġimgħat wara.

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

Kuntest vs Istruzzjonijiet: Meta Tuża X’

Dawn l-erba’ mekkaniżmi jikkoinċidu parzjalment, u l-iżball klassiku huwa li tgħaddi kollox permezz tal-istruzzjonijiet. It-tabella hawn taħt tikkondensa l-mappatura li għandek tiftakar.

ĦtieġaSoluzzjoni
Data tal-utent (isem, rwol)Varjabbli tal-kuntest
Imġiba tal-aġentIstruzzjonijiet (statiċi jew dinamiċi)
Storiku tal-konversazzjoniresult.to_input_list()
Memorja fit-tulGħodod + bażi tad-data
Konfigurazzjoni f’ħin realiVarjabbli tal-kuntest

Punti Ewlenin

  • RunContextWrapper iġorr stat ittajpjat aċċessibbli mill-għodod kollha
  • Il-kuntest huwa mutabbli: l-għodod jistgħu jimmodifikawh waqt l-eżekuzzjoni
  • Istruzzjonijiet dinamiċi (funzjonijiet) jadattaw għall-kuntest f’kull dawra
  • L-istoriku konversazzjonali jinżamm b’result.to_input_list()
  • Għal memorja persistenti, għaqqad għodod tas-salvataġġ ma’ bażi tad-data