Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Mitmeastmeline agent põhjendustsükliga

Õppetund 15 / 25 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Mitmeastmeline agent põhjendustsükliga
  2. Planeeri-käivita muster
  3. Ise paranduv agent
  4. Muster: spetsialiseerunud agentide ahel
  5. Põhjendussügavuse juhtimine
  6. Peamised punktid

Mitmeastmeline agent põhjendustsükliga

Võimsaimad agendid ei peatu pärast ühte tööriistakutset. Nad aheldavad mitu põhjendussammu, kohandavad oma strateegiat tulemuste põhjal ja kordavad protsessi, kuni eesmärgini jõuavad. Selles õppetükis õpid, kuidas selliseid mitmeastmelisi agente luua. Näited kasutavad GPT-5.6 perekonda: kui eelmises põlvkonnas oli põhjendamise võimaldamiseks vaja mudeleid vahetada, siis nüüd saad seda käitumist juhtida valitud mudeli effort (pingutuse) seadistuse kaudu.

Planeeri-käivita muster

Mitmeastmeline agent algab plaani loomisest ja seejärel iga sammu täitmisega. See eraldatus on tahtlik: planeerijal pole tööriistu ja ta toodab tüübitud struktuuri, samas kui täitja saab selle plaani teekaardina ja lihtsalt järgib seda. Ebamäärane päring nagu „valmista võtmeclientide kvartaliülevaade“ muutub enne mis tahes tegevuse alustamist konkreetseks toimingute jadaks – päri CRM-i, genereeri aruanne, saada e-kiri.

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="""Saad keerulise ülesande. Jaota see lihtsateks, järjestatud sammudeks.
    Iga samm peab olema konkreetne ja teostatav tegevus.""",
    model="gpt-5.6-sol",  # Planeerimiseks täiustatud põhjendamine
    output_type=PlanAction,
)

@function_tool
def search_crm(query: str) -> str:
    """Otsib kliendiinfot CRM-ist."""
    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:
    """Genereerib vormindatud aruande."""
    return f"Aruanne '{title}' genereeritud edukalt ({len(content)} tähemärki)"

@function_tool
def send_email(recipient: str, subject: str, body: str) -> str:
    """Saadab e-kirja."""
    return f"E-kiri saadetud aadressile {recipient}: {subject}"

executor_agent = Agent(
    name="Executor",
    instructions="""Täidad ülesandeid samm-sammult.
    Kasuta iga sammu lõpuleviimiseks olemasolevaid tööriistu.
    Kui samm ebaõnnestub, proovi alternatiivset lähenemist.""",
    tools=[search_crm, generate_report, send_email],
    model="gpt-5.6-terra",
)

async def process_complex_task(task: str):
    # 1. samm: Planeeri
    plan = await Runner.run(planner_agent, task)
    print(f"Plaan: {plan.final_output.steps}")

    # 2. samm: Täida, kasutades plaani kontekstina
    execution_instructions = f"""Täida järgmised sammud järjest:
    {chr(10).join(f'{i+1}. {e}' for i, e in enumerate(plan.final_output.steps))}
    Eesmärk: {plan.final_output.objective}"""

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

Ise paranduv agent

Planeerimisest ei piisa: reaalses maailmas ebaõnnestuvad tööriistad. Tsükli teine vorm võimaldagendil tuvastada oma vigu ja need parandada. Kõik sõltub ühest sageli tähelepanuta jäetud detailist – tööriist ei tekita erindit (exception), vaid tagastab loetava veateate. Agent loeb seda, mõistab, et unustas FROM klausli, kirjutab päringu ümber ja proovib uuesti, jäädes oma juhendis määratud kolme katse piiridesse.

from agents import Agent, Runner, function_tool

@function_tool
def execute_sql_query(sql: str) -> str:
    """Käitab SQL-päringu andmebaasis."""
    # Simulatsioon: mõned päringud ebaõnnestuvad
    if "DROP" in sql.upper():
        return "VIGA: Hävitavad päringud on keelatud."
    if "SELECT" in sql.upper() and "FROM" not in sql.upper():
        return "VIGA: Vigane SQL-süntaks – puudub 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="""Analüüsid andmeid SQL-päringuid käitades.
    Kui päring ebaõnnestub:
    1. Analüüsi veateadet
    2. Paranda päringut
    3. Proovi uuesti
    Maksimaalselt 3 katset päringu kohta.
    Ära kasuta kunagi DROP, DELETE ega TRUNCATE.""",
    tools=[execute_sql_query],
    model="gpt-5.6-terra",
    max_turns=10,  # Piisavalt pöördeid paranduste tegemiseks
)

result = Runner.run_sync(
    analyst_agent,
    "Mis on kogutulu piirkonniti?"
)

Pane tähele, et hävitavate päringute keeld ilmneb kahes kohas: juhendis ja tööriista koodis. Juhis suunab mudelit, kuid ainult serveripoolne kontroll tööriistas garanteerib, et DROP TABLE kunagi läbi ei libise.

Muster: spetsialiseerunud agentide ahel

Keerukate töövoogude jaoks ahelda mitu spetsialiseerunud agenti, selle asemel et koormata ühte agenti kõigi vastutustega. Igal lülil on selge roll: koguja hangib toormaterjali, analüütik – varustatud põhjendusmudeliga – tuvastab trendid ja kirjutaja vormindab väljundi. Kasu on nii hariduslik kui ka operatiivne: kui lõpparuanne pettumust valmistab, tead kohe, millist kolmest agendist parandada.

from agents import Agent, Runner

collection_agent = Agent(
    name="Data Collector",
    instructions="Kogu kogu analüüsiks vajalikud andmed.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)

analysis_agent = Agent(
    name="Analyst",
    instructions="Analüüsi kogutud andmeid ja tuvasta trendid.",
    model="gpt-5.6-sol",  # Analüüsiks täiustatud põhjendamine
)

writing_agent = Agent(
    name="Writer",
    instructions="""Kirjuta selge, struktureeritud aruanne inglise keeles,
    lähtudes esitatud analüüsist. Vorming: sissejuhatus, põhipunktid, soovitused.""",
    model="gpt-5.6-terra",
)

async def analysis_pipeline(question: str):
    # 1. samm: Kogu andmed
    data = await Runner.run(collection_agent, question)

    # 2. samm: Analüüsi
    analysis = await Runner.run(
        analysis_agent,
        f"Analüüsi neid andmeid: {data.final_output}"
    )

    # 3. samm: Kirjuta aruanne
    report = await Runner.run(
        writing_agent,
        f"Kirjuta aruanne, lähtudes sellest analüüsist: {analysis.final_output}"
    )

    return report.final_output

Põhjendussügavuse juhtimine

Kõigil neil tsüklitel on üks ühine joon: need ei pruugi kunagi peatuda. Parameeter max_turns on sinu peamine kaitsemechanism ja sa häälestad seda vastavalt ülesande ambitsioonikusele. Kolm pööret piisab agendile, millelt oodatakse vastust esimesel katsel; kakskümmend viis on vaja uurimistööks, mis pärib mitmest allikast enne järelduse tegemist.

# Konservatiivne agent: vähe pöördeid
simple_agent = Agent(
    name="Simple Agent",
    instructions="Vasta võimalusel ühe pöördega.",
    model="gpt-5.6-terra",
)
result = await Runner.run(simple_agent, "Lihtne küsimus", max_turns=3)

# Keerukas agent: palju pöördeid
research_agent = Agent(
    name="Deep Researcher",
    instructions="Uuri kõiki nurki enne järelduse tegemist.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)
result = await Runner.run(research_agent, "Täielik Q1 analüüs", max_turns=25)

Määra see väärtus, jälgides oma jälgi (traces), mitte ei arvake: kui sinu tegelikud täitmised lõpevad kuue pöördega, ei kaitse piirang kakskümmend viis mitte millegi eest.

Peamised punktid

  • Planeeri-käivita muster eraldab planeerimise (põhjendusmudel) täitmisest
  • Ise paranduv agent analüüsib oma vigu ja kohandab strateegiat
  • Spetsialiseerunud agentide ahelad võimaldavad keerukaid ja hooldatavaid töövooge
  • max_turns kontrollib põhjendussügavust ja kaitseb lõpmatute tsüklite eest
  • Reserveeri täiustatud põhjendusvõimekus planeerimiseks ja analüüsiks