Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Architektura agenta: smyčka uvažování a nástrojů

Lekce 2 z 25 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Architektura agenta: smyčka uvažování a nástrojů
  2. Životní cyklus agenta
  3. Vnitřní struktura: položky a zprávy
  4. Paralelní vs. sekvenční volání
  5. Parametr max_turns
  6. Klíčové poznatky

Aktualizováno 3. listopadu 2026: Ve funkci rechercher_produit chyběly u klíčů prix a stock uvozovky, což při prvním volání nástroje způsobovalo chybu NameError.

Architektura agenta: smyčka uvažování a nástrojů

Chceš-li budovat efektivní agenty, musíš pochopit jejich vnitřní architekturu. Agent OpenAI funguje na principu smyčky uvažování: obdrží úkol, přemýšlí, použije nástroj, zhodnotí výsledek a následně se rozhodne, zda je hotovo, nebo zda musí pokračovat. Všechno, co budeš dělat dál – definovat nástroje, nastavovat ochranná pravidla, orchestrace více agentů – vychází z této smyčky.

Životní cyklus agenta

Každé spuštění probíhá v šesti krocích:

  1. Příjem: Agent obdrží zprávu od uživatele a systémové instrukce.
  2. Uvažování: Model analyzuje požadavek a rozhodne se pro další akci.
  3. Volání nástroje: V případě potřeby agent zavolá jeden nebo více nástrojů.
  4. Pozorování: Agent obdrží výsledky z nástrojů.
  5. Rozhodnutí: Agent se rozhodne, zda bude pokračovat (návrat ke kroku 2), nebo odpoví.
  6. Odpověď: Agent vygeneruje svou konečnou odpověď.

Klíčová je smyčka mezi kroky 2 a 5, která může proběhnout mnohokrát. Agent může před vydáním konečné odpovědi řetězit 5, 10 nebo dokonce 20 volání nástrojů, aniž bys musel napsat jediný řádek orchestračného kódu. Níže uvedený příklad to ukazuje: jsou deklarovány dva nezávislé nástroje a model se sám rozhodne, jak je řetězit.

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)

Dotaz vyžaduje dvě operace, které v kódu nejsou explicitně propojeny. Agent automaticky provede dvě volání nástrojů za sebou: nejprve rechercher_produit a poté calculer_remise s získanou cenou. Toto řetězení je rozhodnutím modelu, nikoli tvým pokynem.

Vnitřní struktura: položky a zprávy

API Responses strukturuje každou interakci jako položky (items). Jejich prohlížením zjistíš, co tvůj agent skutečně udělal. V konverzaci se objevují tři typy:

  • message: textová zpráva (od uživatele nebo od agenta)
  • function_call: volání nástroje, které se agent rozhodl provést
  • function_call_output: výsledek vrácený nástrojem
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 tuto smyčku trasovat pokaždé, když agent odpoví překvapivě. Devět z deseti případů se anomálie projeví v function_call s neočekávanými argumenty.

Paralelní vs. sekvenční volání

Ne všechny kroky na sobě závisí. Pokud jsou dvě volání nezávislá, agent se může rozhodnout spustit je paralelně.

@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časí v Lyonu nezávisí na počasí v Paříži: SDK zpracovává paralelismus automaticky a spustí obě volání současně, čímž snižuje latenci. Porovnej to s předchozím příkladem prodeje, kde musel výpočet slevy počkat na cenu: tam se posloupnost vynucuje sama.

Parametr max_turns

Autonomní smyčka může v nejhorším případě nikdy neskončit: agent zavolá nástroj, výsledek ho přiměje zavolat další a tak dále. Ochranným prvkem je jediný parametr.

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

Pokud agent dosáhne limitu, zastaví se s dosud získanými výsledky. V produkčním prostředí je to zásadní bezpečnostní prvek: omezuje jak dobu odezvy, tak náklady.

Klíčové poznatky

  • Agent běží ve smyčce: uvažování → nástroj → pozorování → rozhodnutí
  • Tato smyčka může před vydáním odpovědi proběhnout vícekrát
  • Model se automaticky rozhoduje, které nástroje zavolat a v jakém pořadí
  • Nezávislá volání nástrojů běží paralelně
  • max_turns limituje počet iterací z důvodu bezpečnosti