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

Agent vícekrokový s reasoning smyčkou

Lekce 15 z 25 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Agent vícekrokový s reasoning smyčkou
  2. Vzorec plánování a provádění (Plan-Execute)
  3. Samokorigující se agent
  4. Vzorec: řetězec specializovaných agentů
  5. Řízení hloubky reasoningu
  6. Klíčové poznatky

Agent vícekrokový s reasoning smyčkou

Nejsilnější agenti se nezastaví po jediném volání nástroje. Řetězí více kroků uvažování, upravují svou strategii na základě výsledků a iterují, dokud nedosáhnou cíle. V této lekci se naučíš, jak tyto vícekrokové agenty stavět. Příklady využívají rodinu modelů GPT-5.6: zatímco předchozí generace vyžadovala přepínání modelů pro aktivaci reasoningu, nyní toto chování řídíš nastavením parametru effort u zvoleného modelu.

Vzorec plánování a provádění (Plan-Execute)

Vícekrokový agent začíná vytvořením plánu a následně provádí každý jeho krok. Toto oddělení je záměrné: plánovač nemá přístup k nástrojům a produkuje typovanou strukturu, zatímco vykonavatel obdrží tento plán jako mapu a jednoduše jej následuje. Vágní požadavek typu „připrav čtvrtletní přehled pro klíčové účty“ se změní na konkrétní sekvenci akcí – dotaz do CRM, vygenerování reportu, odeslání e-mailu – ještě předtím, než je podniknut jakýkoli krok.

from agents import Agent, Runner, function_tool
from pydantic import BaseModel
import json

class PlanAction(BaseModel):
    steps: list[str]
    objective: str

planner_agent = Agent(
    name="Planner",
    instructions="""Obdržíš komplexní úkol. Rozlož jej na jednoduché, seřazené kroky.
    Každý krok musí být konkrétní a proveditelná položka.""",
    model="gpt-5.6-sol",  # Pokročilý reasoning pro plánování
    output_type=PlanAction,
)

@function_tool
def search_crm(query: str) -> str:
    """Vyhledá informace o zákaznících v CRM."""
    return json.dumps({"customers": [
        {"name": "Acme Corp", "revenue": 500000, "contract": "Enterprise"},
        {"name": "TechStart", "revenue": 50000, "contract": "Starter"},
    ]})

@function_tool
def generate_report(title: str, content: str) -> str:
    """Vygeneruje formátovaný report."""
    return f"Report '{title}' úspěšně vygenerován ({len(content)} znaků)"

@function_tool
def send_email(recipient: str, subject: str, body: str) -> str:
    """Odešle e-mail."""
    return f"E-mail odeslán na {recipient}: {subject}"

executor_agent = Agent(
    name="Executor",
    instructions="""Úkoly provádíš krok za krokem.
    K dokončení každého kroku použij dostupné nástroje.
    Pokud krok selže, zkus alternativní přístup.""",
    tools=[search_crm, generate_report, send_email],
    model="gpt-5.6-terra",
)

async def process_complex_task(task: str):
    # Krok 1: Plánování
    plan = await Runner.run(planner_agent, task)
    print(f"Plán: {plan.final_output.steps}")

    # Krok 2: Provedení s plánem jako kontextem
    execution_instructions = f"""Proveď následující kroky v pořadí:
    {chr(10).join(f'{i+1}. {e}' for i, e in enumerate(plan.final_output.steps))}
    Cíl: {plan.final_output.objective}"""

    result = await Runner.run(executor_agent, execution_instructions)
    return result.final_output

Samokorigující se agent

Samotné plánování nestačí: v reálném světě nástroje selhávají. Druhá forma smyčky umožňuje agentovi detekovat vlastní chyby a opravit je. Všechno závisí na detailu, který se často přehlíží – nástroj nevyhodí výjimku, ale vrátí čitelnou chybovou zprávu. Agent si ji přečte, uvědomí si, že zapomněl na klauzuli FROM, přepíše svůj dotaz a zkusí to znovu, v rámci limitu tří pokusů stanoveného v jeho instrukcích.

from agents import Agent, Runner, function_tool

@function_tool
def execute_sql_query(sql: str) -> str:
    """Provede SQL dotaz na databázi."""
    # Simulace: některé dotazy selžou
    if "DROP" in sql.upper():
        return "CHYBA: Destruktivní dotazy jsou zakázány."
    if "SELECT" in sql.upper() and "FROM" not in sql.upper():
        return "CHYBA: Neplatná syntaxe SQL – chybí FROM."
    return json.dumps({
        "columns": ["name", "monthly_revenue", "region"],
        "rows": [
            ["Acme Corp", 45000, "Île-de-France"],
            ["TechStart", 12000, "Rhône-Alpes"],
        ],
        "result_count": 2
    })

analyst_agent = Agent(
    name="Data Analyst",
    instructions="""Analyzuješ data prováděním SQL dotazů.
    Pokud dotaz selže:
    1. Analyzuj chybovou zprávu
    2. Oprav dotaz
    3. Zkus to znovu
    Maximálně 3 pokusy na jeden dotaz.
    Nikdy nepoužívej DROP, DELETE ani TRUNCATE.""",
    tools=[execute_sql_query],
    model="gpt-5.6-terra",
    max_turns=10,  # Dostatek kol pro opravy
)

result = Runner.run_sync(
    analyst_agent,
    "Jaký je celkový výnos podle regionů?"
)

Všimni si, že zákaz destruktivních dotazů se objevuje na dvou místech: v instrukcích i v kódu nástroje. Instrukce model navádějí, ale pouze kontrola na straně serveru v nástroji garantuje, že příkaz DROP TABLE nikdy neproklouzne.

Vzorec: řetězec specializovaných agentů

Pro komplexní workflow je lepší řetězit několik specializovaných agentů, nežli zatěžovat jednoho agenta veškerou odpovědností. Každý článek má jasnou roli: sběrač shromažďuje surový materiál, analytik – vybavený reasoning modelem – identifikuje trendy a spisovatel formátuje výstup. Přínos je jak vzdělávací, tak provozní: když výsledný report zklame, okamžitě víš, kterého ze tří agentů je třeba opravit.

from agents import Agent, Runner

collection_agent = Agent(
    name="Data Collector",
    instructions="Shromáždi všechna data potřebná pro analýzu.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)

analysis_agent = Agent(
    name="Analyst",
    instructions="Analyzuj shromážděná data a identifikuj trendy.",
    model="gpt-5.6-sol",  # Pokročilý reasoning pro analýzu
)

writing_agent = Agent(
    name="Writer",
    instructions="""Napiš jasný, strukturovaný report v angličtině
    na základě poskytnuté analýzy. Formát: úvod, klíčové body, doporučení.""",
    model="gpt-5.6-terra",
)

async def analysis_pipeline(question: str):
    # Krok 1: Sběr dat
    data = await Runner.run(collection_agent, question)

    # Krok 2: Analýza
    analysis = await Runner.run(
        analysis_agent,
        f"Analyzuj tato data: {data.final_output}"
    )

    # Krok 3: Napsání reportu
    report = await Runner.run(
        writing_agent,
        f"Napiš report na základě této analýzy: {analysis.final_output}"
    )

    return report.final_output

Řízení hloubky reasoningu

Všechny tyto smyčky mají jednu společnou vlastnost: mohou se nikdy nezastavit. Parametr max_turns je tvou hlavní pojistkou a ladíš jej podle ambicí úkolu. Tři kola stačí pro agenta, od kterého se očekává odpověď na první pokus; dvacet pět je potřeba pro průzkum, který před závěrem dotazuje více zdrojů.

# Konzervativní agent: málo kol
simple_agent = Agent(
    name="Simple Agent",
    instructions="Odpověz pokud možno v jediném kole.",
    model="gpt-5.6-terra",
)
result = await Runner.run(simple_agent, "Jednoduchá otázka", max_turns=3)

# Komplexní agent: mnoho kol
research_agent = Agent(
    name="Deep Researcher",
    instructions="Prozkoumej všechny úhly pohledu, než dospěješ k závěru.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)
result = await Runner.run(research_agent, "Kompletní analýza Q1", max_turns=25)

Tuto hodnotu nastavuj na základě pozorování svých tras (traces), nikoliv hádáním: pokud se tvá skutečná provedení dokončí za šest kol, limit dvaceti pěti nic nechrání.

Klíčové poznatky

  • Vzorec plánování a provádění odděluje plánování (reasoning model) od exekuce
  • Samokorigující se agent analyzuje své chyby a upravuje svou strategii
  • Řetězce specializovaných agentů umožňují komplexní a udržovatelná workflow
  • max_turns řídí hloubku reasoningu a chrání před nekonečnými smyčkami
  • Pokročilé reasoning schopnosti si rezervuj pro plánování a analýzu