Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Athróga Comhthéacs agus Cuimhne Ghníomhaire

Ceacht 13 as 25 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Athróga Comhthéacs agus Cuimhne Ghníomhaire
  2. Athróga Comhthéacs: Stát Roinnte
  3. Treoracha Dinimiciúla
  4. Cuimhne Chomhráite Il-Chasadh
  5. Patrún: Cuimhne Bhuan le Bunachar Sonraí
  6. Comhthéacs vs. Treoracha: Cathain Úsáid a Bhaint as Cad
  7. Príomhphointí

Athróga Comhthéacs agus Cuimhne Ghníomhaire

Déanann gníomhaire gan chuimhne dearmad de gach rud idir riteanna: iarrann sé ainm an chustaiméara i ngach teachtaireacht agus tosaíonn sé ón mbun ag gach casadh. Deisíonn dhá mheicníocht chomhlántacha é seo. Cuirtear stát roinnte isteach sa ghníomhaire agus ina uirlisí trí athróga comhthéacs, agus coinníonn cuimhne chomhráite snáithe comhrá il-chasadh.

Athróga Comhthéacs: Stát Roinnte

Is oibiacht chlóscríofa é an RunContextWrapper a imríonn idir an gníomhaire, a chuid uirlisí, agus a chuid cosaintí (guardrails). Go sonrach, sainíonn tú dataclass a chuireann síos ar an seisiún—aitheantas, cartán, roghanna—agus faigheann gach uirlis é mar an chéad pharaiméadar. Sa sampla thíos, scríobhann ajouter_au_panier chuig an oibiacht seo agus léann voir_panier ar ais í: roinneann an dá uirlis an cartán céanna gan aon sonraí a rith tríd an leid (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}")

Tá an comhthéacs so-athraithe: is féidir le huirlisí é a mhodhnú, agus fanann na hathruithe i bhfeidhm tar éis an fhorghníomhaithe. Sin é an fáth a bhfuil an líne dheireanach suimiúil—tar éis run_sync, tá an dá mhír i do oibiacht seisiún feidhmchláir i ndáiríre, réidh le seoladh chuig do chóras ordaithe.

Treoracha Dinimiciúla

Ní hamháin d’uirlisí atá an stát seo: is féidir leis iompar an ghníomhaire a mhúnlú freisin. Is féidir le treoracha a bheith ina bhfeidhm a fhaigheann an comhthéacs agus a thógann an leid córais ar an eitilt, ag cur ainm an chustaiméara agus an teanga is fearr leo san áireamh.

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

Déantar meastóireacht ar threoracha ag gach casadh den lúb gníomhaire, rud a chumasaí pearsantú fíor-ama: má chuir uirlis mír leis díreach, déanann an chéad chasadh cuntas air láithreach sa leid córais.

Cuimhne Chomhráite Il-Chasadh

Iompraíonn an comhthéacs sonraí, ní an comhrá féin. Chun comhrá a choinneáil thar malartuithe iolracha, cuir an stair ar aghaidh. Tagann an prionsabal anuas ar thrí chéim: cuireann tú teachtaireacht an úsáideora leis, rithann tú an gníomhaire ar an liosta iomlán, agus ansin cuirtear do stair in ionad na staire a thugtar ar ais ag an toradh—ag gabháil teachtaireachtaí, glaonna uirlisí, agus freagraí.

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

Maireann an chuimhne seo sa RAM. Imíonn sí nuair a ath-imlonnaíonn tú do sheirbhís, agus fásann sí go deo má mhaireann an comhrá: dhá theorainn le coinneáil i gcuimhne sula dtéann tú go dtí an táirgeadh.

Patrún: Cuimhne Bhuan le Bunachar Sonraí

Chun cuimhne a mhaireann tar éis atosaithe, stóráil an stair i mbunachar sonraí. Téann an cur chuige a chuirtear i láthair anseo céim níos faide: in ionad gach rud a choinneáil, cinneann an gníomhaire féin cad atá fiú a choinneáil, trí phéire uirlisí sábhála agus aisghabhála. Deir an custaiméir “Tá ailléirge agam ar phiseanna talún”, glaonn an gníomhaire sauvegarder_note, agus fanann an fhaisnéis ar fáil trí seachtaine ina dhiaidh sin.

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

Comhthéacs vs. Treoracha: Cathain Úsáid a Bhaint as Cad

Tá forluí páirteach ag na ceithre mheicníocht seo, agus is é an botún clasaiceach gach rud a ródú trí threoracha. Aimsíonn an tábla thíos an mapáil le cuimhneamh air.

RiachtanasRéiteach
Sonraí úsáideora (ainm, ról)Athróga comhthéacs
Iompar gníomhaireTreoracha (statach nó dinimiciúil)
Stair chomhráresult.to_input_list()
Cuimhne fhadtéarmachUirlisí + bunachar sonraí
Cumraíocht rith-amaAthróga comhthéacs

Príomhphointí

  • Iompraíonn RunContextWrapper stát clóscríofa atá inrochtana ag gach uirlis
  • Tá an comhthéacs so-athraithe: is féidir le huirlisí é a mhodhnú le linn forghníomhaithe
  • Oiriúnaíonn treoracha dinimiciúla (feidhmeanna) don chomhthéacs ag gach casadh
  • Coinnítear stair chomhráite le result.to_input_list()
  • Chun cuimhne bhuan a fháil, comhcheangail uirlisí sábhála le bunachar sonraí