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

Viackrokový agent s cyklom usudzovania

Lekcia 15 z 25 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Viackrokový agent s cyklom usudzovania
  2. Vzorec plánuj a vykonávaj
  3. Samokorigujúci sa agent
  4. Vzorec: reťazec špecializovaných agentov
  5. Riadenie hĺbky usudzovania
  6. Kľúčové poznatky

Viackrokový agent s cyklom usudzovania

Najsilnejší agenti sa nezastavia po jedinom volaní nástroja. Spájajú viacero krokov usudzovania, upravujú svoju stratégiu na základe výsledkov a iterujú, kým nedosiahnu svoj cieľ. V tejto lekcii sa naučíš, ako stavať týchto viackrokových agentov. Príklady využívajú rodinu modelov GPT-5.6: zatiaľ čo predchádzajúca generácia si vyžadovala prepínanie modelov na aktiváciu usudzovania, teraz toto správanie riadiš nastavením úsilia (effort) na zvolenom modeli.

Vzorec plánuj a vykonávaj

Viackrokový agent začína vytvorením plánu a následne vykonáva každý jeho krok. Toto oddelenie je zámerné: plánovač nemá žiadne nástroje a produkuje typovanú štruktúru, zatiaľ čo vykonávateľ dostáva tento plán ako cestovnú mapu a jednoducho ho nasleduje. Vágna požiadavka typu „priprav štvrťročný prehľad pre kľúčové účty“ sa zmení na konkrétnu postupnosť akcií – dotaz do CRM, vygenerovanie správy, odoslanie e-mailu – ešte predtým, než sa pokúsi o akúkoľvek činnosť.

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="""Dostaneš komplexnú úlohu. Rozdeľ ju na jednoduché, usporiadané kroky.
    Každý krok musí byť konkrétna, realizovateľná položka.""",
    model="gpt-5.6-sol",  # Pokročilé usudzovanie pre plánovanie
    output_type=PlanAction,
)

@function_tool
def search_crm(query: str) -> str:
    """Vyhľadáva informácie o zákazníkoch 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:
    """Generuje formátovanú správu."""
    return f"Správa '{title}' úspešne vygenerovaná ({len(content)} znakov)"

@function_tool
def send_email(recipient: str, subject: str, body: str) -> str:
    """Odošle e-mail."""
    return f"E-mail odoslaný pre {recipient}: {subject}"

executor_agent = Agent(
    name="Executor",
    instructions="""Úlohy vykonávaš krok za krokom.
    Na dokončenie každého kroku použij dostupné nástroje.
    Ak krok zlyhá, skús alternatívny prístup.""",
    tools=[search_crm, generate_report, send_email],
    model="gpt-5.6-terra",
)

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

    # Krok 2: Vykonanie s plánom ako kontextom
    execution_instructions = f"""Vykonaj nasledujúce kroky v poradí:
    {chr(10).join(f'{i+1}. {e}' for i, e in enumerate(plan.final_output.steps))}
    Cieľ: {plan.final_output.objective}"""

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

Samokorigujúci sa agent

Samotné plánovanie nestačí: v reálnom svete nástroje zlyhávajú. Druhá forma cyklu umožňuje agentovi odhaliť vlastné chyby a opraviť ich. Všetko závisí od detailu, ktorý sa často prehliada – nástroj nevyhodí výnimku, ale vráti čitateľnú chybovú správu. Agent si ju prečíta, uvedomí si, že zabudol na klauzulu FROM, prepíše svoj dotaz a skúsi to znova, v rámci limitu troch pokusov stanoveného v jeho inštrukciách.

from agents import Agent, Runner, function_tool

@function_tool
def execute_sql_query(sql: str) -> str:
    """Vykoná SQL dotaz na databáze."""
    # Simulácia: niektoré dotazy zlyhajú
    if "DROP" in sql.upper():
        return "CHYBA: Deštruktívne dotazy sú zakázané."
    if "SELECT" in sql.upper() and "FROM" not in sql.upper():
        return "CHYBA: Neplatná syntax SQL - chýba 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š údaje vykonávaním SQL dotazov.
    Ak dotaz zlyhá:
    1. Analyzuj chybovú správu
    2. Oprav dotaz
    3. Skús to znova
    Maximálne 3 pokusy na jeden dotaz.
    Nikdy nepoužívaj DROP, DELETE ani TRUNCATE.""",
    tools=[execute_sql_query],
    model="gpt-5.6-terra",
    max_turns=10,  # Dosť kôl na opravy
)

result = Runner.run_sync(
    analyst_agent,
    "Aký je celkový výnos podľa regiónu?"
)

Všimni si, že zákaz deštruktívnych dotazov sa objavuje na dvoch miestach: v inštrukciách aj v kóde nástroja. Inštrukcia usmerňuje model, ale iba kontrola na strane servera v nástroji zaručuje, že príkaz DROP TABLE nikdy neprejde.

Vzorec: reťazec špecializovaných agentov

Pre komplexné pracovné postupy prepoj niekoľko špecializovaných agentov namiesto toho, aby si jedného agenta zaťažoval každou zodpovednosťou. Každý článok má jasnú úlohu: zberateľ zhromažďuje surový materiál, analytik – vybavený modelom usudzovania – identifikuje trendy a pisateľ formátuje výstup. Prínos je vzdelávací aj operačný: keď výsledná správa sklame, okamžite vieš, ktorého z troch agentov treba opraviť.

from agents import Agent, Runner

collection_agent = Agent(
    name="Data Collector",
    instructions="Zhromaždi všetky údaje potrebné pre analýzu.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)

analysis_agent = Agent(
    name="Analyst",
    instructions="Analyzuj zhromaždené údaje a identifikuj trendy.",
    model="gpt-5.6-sol",  # Pokročilé usudzovanie pre analýzu
)

writing_agent = Agent(
    name="Writer",
    instructions="""Napíš jasnú, štruktúrovanú správu v angličtine
    na základe poskytnutej analýzy. Formát: úvod, kľúčové body, odporúčania.""",
    model="gpt-5.6-terra",
)

async def analysis_pipeline(question: str):
    # Krok 1: Zber údajov
    data = await Runner.run(collection_agent, question)

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

    # Krok 3: Napísanie správy
    report = await Runner.run(
        writing_agent,
        f"Napíš správu na základe tejto analýzy: {analysis.final_output}"
    )

    return report.final_output

Riadenie hĺbky usudzovania

Všetky tieto cykly majú jednu spoločnú črtu: môžu sa nikdy nezastaviť. Parameter max_turns je tvoja hlavná poistka a ladíš ho podľa ambicióznosti úlohy. Tri kolá stačia pre agenta, od ktorého sa očakáva odpoveď na prvý pokus; dvadsaťpäť je potrebných pre prieskum, ktorý pred záverom dopytuje viacero zdrojov.

# Konzervatívny agent: málo kôl
simple_agent = Agent(
    name="Simple Agent",
    instructions="Odpovedz v jednom kole, ak je to možné.",
    model="gpt-5.6-terra",
)
result = await Runner.run(simple_agent, "Jednoduchá otázka", max_turns=3)

# Komplexný agent: veľa kôl
research_agent = Agent(
    name="Deep Researcher",
    instructions="Preskúmaj všetky uhly predtým, než vyvodíš záver.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)
result = await Runner.run(research_agent, "Kompletná analýza Q1", max_turns=25)

Túto hodnotu nastavuj na základe pozorovania tvojich stôp (traces), nie hádaním: ak sa tvoje skutočné vykonania skončia na šiestom kole, limit dvadsaťpäť nič neochráni.

Kľúčové poznatky

  • Vzorec „plánuj a vykonávaj“ oddeľuje plánovanie (model usudzovania) od vykonávania
  • Samokorigujúci sa agent analyzuje svoje chyby a upravuje svoju stratégiu
  • Reťazce špecializovaných agentov umožňujú komplexné a udržiavateľné pracovné postupy
  • max_turns riadi hĺbku usudzovania a chráni pred nekonečnými cyklami
  • Pokročilé schopnosti usudzovania si vyhradź pre plánovanie a analýzu