Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Architektúra agenta: cyklus nástroj–usudzovanie

Lekcia 2 z 25 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Architektúra agenta: cyklus nástroj–usudzovanie
  2. Životný cyklus agenta
  3. Vnútorná štruktúra: položky a správy
  4. Paralelné versus sekvenčné volania
  5. Parameter max_turns
  6. Kľúčové poznatky

Aktualizované 3. novembra 2026: Vo funkcii rechercher_produit chýbali úvodzovky okľúčov prix a stock, čo spôsobovalo chybu NameError pri prvom volaní nástroja.

Architektúra agenta: cyklus nástroj–usudzovanie

Aby si dokázal budovať efektívnych agentov, musíš pochopiť ich vnútornú architektúru. Agent OpenAI funguje na princípe cyklu usudzovania: dostane úlohu, premyslí si ju, použije nástroj, vyhodnotí výsledok a následne sa rozhodne, či je hotový, alebo musí pokračovať. Všetko, čo budeš robiť ďalej – definovanie nástrojov, nastavenie ochranných mechanizmov, orchestrácia viacerých agentov – vychádza práve z tohto cyklu.

Životný cyklus agenta

Každé spustenie prebieha v šiestich krokoch:

  1. Príjem: Agent dostane správu od používateľa a systémové inštrukcie.
  2. Usudzovanie: Model analyzuje požiadavku a rozhodne sa pre ďalší krok.
  3. Volanie nástroja: V prípade potreby agent zavolá jeden alebo viacero nástrojov.
  4. Pozorovanie: Agent prijme výsledky z nástrojov.
  5. Rozhodnutie: Agent sa rozhodne, či bude pokračovať (návrat na krok 2), alebo odpovie.
  6. Odpoveď: Agent vygeneruje svoju konečnú odpoveď.

Kľúčom je slučka medzi krokmi 2 a 5, ktorá sa môže vykonať viackrát. Agent dokáže pred vygenerovaním konečnej odpovede zreťaziť 5, 10 alebo dokonca 20 volaní nástrojov, pričom ty nemusíš napísať ani riadok kódu pre orchestráciu. Nasledujúci príklad to ilustruje: sú deklarované dva nezávislé nástroje a model sa sám rozhodne, ako ich zreťazí.

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)

Otázka si vyžaduje dve operácie, ktoré nie sú v kóde explicitne prepojené. Agent automaticky vykoná dve volania nástrojov po sebe: najprv rechercher_produit a potom calculer_remise so získanou cenou. Toto reťazenie je rozhodnutím modelu, nie tvojou inštrukciou.

Vnútorná štruktúra: položky a správy

API Responses štruktúruje každú interakciu ako položky (items). Ich preskúmanie ti ukáže, čo agent skutočne vykonal. V konverzácii sa objavujú tri typy:

  • message: textová správa (od používateľa alebo od agenta)
  • function_call: volanie nástroja, ktoré sa rozhodol vykonať agent
  • function_call_output: výsledok vrátený nástrojom
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

Zvykni si sledovať tento cyklus vždy, keď agent vyprodukuje neočakávanú odpoveď. Deväťkrát z desiatich sa anomália prejaví v položke function_call s neočakávanými argumentmi.

Paralelné versus sekvenčné volania

Nie všetky kroky sú na sebe závislé. Keď sú dve volania nezávislé, agent sa môže rozhodnúť spustiť ich paralelne.

@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?"
)

Počasie v Lyone nezávisí od počasia v Paríži: SDK automaticky zabezpečí paralelizmus a spustí obe volania súčasne, čím sa zníži latencia. Porovnaj to s predchádzajúcim príkladom predaja, kde výpočet zľavy musel počkať na cenu: tam sa sekvencia vynútila sama.

Parameter max_turns

Autonómna slučka môže v najhoršom prípade nikdy neskončiť: agent zavolá nástroj, výsledok ho donúti zavolať ďalší a tak ďalej. Ochranným mechanizmom je jediný parameter.

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

Ak agent dosiahne tento limit, zastaví sa s doteraz získanými výsledkami. V produkčnom prostredí je toto nevyhnutná bezpečnostná poistka: obmedzuje čas odozvy aj náklady.

Kľúčové poznatky

  • Agent beží v cykle: usudzovanie → nástroj → pozorovanie → rozhodnutie
  • Tento cyklus sa môže vykonať viackrát pred vygenerovaním odpovede
  • Model sa automaticky rozhoduje, ktoré nástroje zavolať a v akom poradí
  • Nezávislé volania nástrojov sa spúšťajú paralelne
  • Parameter max_turns obmedzuje počet iterácií z bezpečnostných dôvodov