Arhitectura agentului: bucla de raționament și instrumente
Pe această pagină
Actualizat la 3 noiembrie 2026: În funcția
rechercher_produit, cheileprixșistocknu aveau ghilimele, ceea ce provoca o eroareNameErrorla 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:
- Recepție: Agentul primește mesajul utilizatorului și instrucțiunile de sistem.
- Raționament: Modelul analizează cererea și decide următoarea acțiune.
- Apel de instrument: Dacă este necesar, agentul apelează unul sau mai multe instrumente.
- Observație: Agentul primește rezultatele instrumentelor.
- Decizie: Agentul decide dacă continuă (revenind la pasul 2) sau răspunde.
- 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 agentfunction_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_turnslimitează numărul de iterații din motive de siguranță