Viackrokový agent s cyklom usudzovania
Na tejto strane
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_turnsriadi hĺbku usudzovania a chráni pred nekonečnými cyklami- Pokročilé schopnosti usudzovania si vyhradź pre plánovanie a analýzu