Salt la conținutul principal
Română— Alege o limbă
Meniu

Arhitectura agentului: bucla de raționament și instrumente

Lecția 2 din 25 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Arhitectura agentului: bucla de raționament și instrumente
  2. Ciclul de viață al agentului
  3. Structura internă: elemente și mesaje
  4. Apeluri paralele versus secvențiale
  5. Parametrul max_turns
  6. Puncte cheie

Actualizat la 3 noiembrie 2026: În funcția rechercher_produit, cheile prix și stock nu aveau ghilimele, ceea ce provoca o eroare NameError la prima apelare a instrumentului.

Arhitectura agentului: bucla de raționament și instrumente

Pentru a construi agenți eficienți, trebuie să le înțelegeți arhitectura internă. Un agent OpenAI funcționează pe baza unei bucle de raționament: primește o sarcină, gândește, utilizează un instrument, observă rezultatul și apoi decide dacă a terminat sau dacă trebuie să continue. Tot ceea ce veți face în continuare – declararea instrumentelor, stabilirea gardurilor de siguranță, orchestrarea mai multor agenți – se bazează pe această buclă.

Ciclul de viață al agentului

Fiecare execuție urmează șase pași:

  1. Recepție: Agentul primește mesajul utilizatorului și instrucțiunile de sistem.
  2. Raționament: Modelul analizează cererea și decide următoarea acțiune.
  3. Apel de instrument: Dacă este necesar, agentul apelează unul sau mai multe instrumente.
  4. Observație: Agentul primește rezultatele instrumentelor.
  5. Decizie: Agentul decide dacă continuă (revenind la pasul 2) sau răspunde.
  6. Răspuns: Agentul produce răspunsul final.

Elementul cheie este bucla dintre pașii 2 și 5, care se poate executa de mai multe ori. Un agent poate înlănțui 5, 10 sau chiar 20 de apeluri de instrumente înainte de a produce un răspuns final, fără ca dumneavoastră să scrieți o singură linie de cod de orchestrare. Exemplul de mai jos ilustrează acest lucru: sunt declarate două instrumente independente, iar modelul decide cum să le înlănțuie.

from agents import Agent, Runner, function_tool

@function_tool
def rechercher_produit(nom: str) -> str:
    """Searches for a product in the catalog."""
    # Simulation - in production, call your database
    catalogue = {
        "laptop-pro": {"prix": 1299, "stock": 45},
        "tablet-air": {"prix": 599, "stock": 120},
    }
    produit = catalogue.get(nom)
    if produit:
        return f"Produit {nom}: {produit['prix']}€, stock: {produit['stock']}"
    return f"Produit {nom} non trouvé"

@function_tool
def calculer_remise(prix: float, pourcentage: float) -> str:
    """Calculates the price after discount."""
    prix_final = prix * (1 - pourcentage / 100)
    return f"Prix après {pourcentage}% de remise : {prix_final:.2f}€"

agent = Agent(
    name="Sales Agent",
    instructions="You help customers find products and calculate discounts.",
    tools=[rechercher_produit, calculer_remise],
    model="gpt-5.6-terra",
)

# The agent will: 1) find the product, 2) calculate the discount, 3) respond
result = Runner.run_sync(
    agent,
    "What is the price of the laptop-pro with a 15% discount?"
)
print(result.final_output)

Întrebarea necesită două operațiuni care nu sunt legate explicit în cod. Agentul efectuează automat două apeluri de instrumente în secvență: mai întâi rechercher_produit, apoi calculer_remise cu prețul recuperat. Această înlănțuire este o decizie a modelului, nu o instrucțiune din partea dumneavoastră.

Structura internă: elemente și mesaje

API-ul Responses structurează fiecare interacțiune sub formă de elemente (items). Analizându-le, veți vedea ce a făcut efectiv agentul dumneavoastră. Trei tipuri apar în conversație:

  • message: un mesaj text (de la utilizator sau de la agent)
  • function_call: un apel de instrument decis de agent
  • function_call_output: rezultatul returnat de instrument
result = Runner.run_sync(agent, "Find the tablet-air")

# Inspect the reasoning steps
for item in result.raw_responses:
    print(f"Type: {type(item).__name__}")
    # You'll see: message input → function_call → function_call_output → message output

Obișnuiți-vă să urmăriți această buclă de fiecare dată când un agent produce un răspuns surprinzător. De nouă ori din zece, anomalia apare într-un function_call cu argumente neașteptate.

Apeluri paralele versus secvențiale

Nu toți pașii depind unii de alții. Atunci când două apeluri sunt independente, agentul poate decide să le execute în paralel.

@function_tool
def obtenir_meteo(ville: str) -> str:
    """Gets the current weather for a city."""
    meteos = {"Paris": "18°C, sunny", "Lyon": "16°C, cloudy"}
    return meteos.get(ville, "Data unavailable")

agent = Agent(
    name="Travel Agent",
    instructions="You help plan trips.",
    tools=[obtenir_meteo, rechercher_produit],
    model="gpt-5.6-terra",
)

# The agent will call obtenir_meteo("Paris") and obtenir_meteo("Lyon") in parallel
result = Runner.run_sync(
    agent,
    "What's the weather in Paris and Lyon?"
)

Vremea din Lyon nu depinde de cea din Paris: SDK-ul gestionează automat paralelismul și lansează ambele apeluri simultan, reducând latența. Comparați acest lucru cu exemplul de vânzări de mai sus, unde calculul reducerii a trebuit să aștepte prețul: acolo, secvența se impune de la sine.

Parametrul max_turns

O buclă autonomă poate, în cel mai rău caz, să nu se oprească niciodată: agentul apelează un instrument, rezultatul îl determină să apeleze altul și tot așa. Măsura de siguranță este un singur parametru.

result = Runner.run_sync(
    agent,
    "Full catalog analysis",
    max_turns=10  # Maximum 10 loop iterations
)

Dacă agentul atinge limita, se oprește cu rezultatele obținute până în acel moment. În producție, aceasta este o măsură de siguranță esențială: limitează atât timpul de răspuns, cât și costul.

Puncte cheie

  • Un agent rulează într-o buclă: raționament → instrument → observație → decizie
  • Această buclă se poate executa de mai multe ori înainte de a produce un răspuns
  • Modelul decide automat ce instrumente să apeleze și în ce ordine
  • Apelurile de instrumente independente rulează în paralel
  • max_turns limitează numărul de iterații din motive de siguranță