Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Večstopenjski agent z zanko razmišljanja

Lekcija 15 od 25 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Večstopenjski agent z zanko razmišljanja
  2. Vzorec načrtuj-izvedi
  3. Samopopravljajoči se agent
  4. Vzorec: veriga specializiranih agentov
  5. Nadzor globine razmišljanja
  6. Ključne ugotovitve

Večstopenjski agent z zanko razmišljanja

Najzmogljivejši agenti se ne ustavijo po enem samem klicu orodja. Povežejo več korakov razmišljanja, prilagodijo svojo strategijo glede na rezultate in iterirajo, dokler ne dosežejo cilja. V tej lekciji se boš naučil graditi takšne večstopenjske agente. Primeri uporabljajo družino modelov GPT-5.6: kjer je prejšnja generacija zahtevala menjavo modelov za omogočanje razmišljanja, zdaj to vedenje nadziraš prek nastavitve effort na izbranem modelu.

Vzorec načrtuj-izvedi

Večstopenjski agent najprej ustvari načrt, nato pa izvede vsak korak. Ta ločitev je namerna: načrtovalec nima orodij in proizvede tipizirano strukturo, medtem ko izvajalec prejme ta načrt kot zemljevid in ga preprosto sledi. Nejasna zahteva, kot je „pripravi četrtletni pregled za ključne stranke”, postane konkretno zaporedje dejanj—poizvedi v CRM, ustvari poročilo, pošlji e-pošto—preden se poskusi katerokoli dejanje.

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="""Prejmeš kompleksno nalogo. Razčleni jo na preproste, urejene korake.
    Vsak korak mora biti konkreten, izvedljiv element.""",
    model="gpt-5.6-sol",  # Napredno razmišljanje za načrtovanje
    output_type=PlanAction,
)

@function_tool
def search_crm(query: str) -> str:
    """Poišče informacije o strankah 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:
    """Ustvari formatirano poročilo."""
    return f"Report '{title}' generated successfully ({len(content)} characters)"

@function_tool
def send_email(recipient: str, subject: str, body: str) -> str:
    """Pošlje e-pošto."""
    return f"Email sent to {recipient}: {subject}"

executor_agent = Agent(
    name="Executor",
    instructions="""Naloge izvajaš korak za korakom.
    Za dokončanje vsakega koraka uporabi razpoložljiva orodja.
    Če korak ne uspe, poskusi alternativni pristop.""",
    tools=[search_crm, generate_report, send_email],
    model="gpt-5.6-terra",
)

async def process_complex_task(task: str):
    # 1. korak: Načrtuj
    plan = await Runner.run(planner_agent, task)
    print(f"Plan: {plan.final_output.steps}")

    # 2. korak: Izvedi z načrtom kot kontekstom
    execution_instructions = f"""Izvedi naslednje korake po vrsti:
    {chr(10).join(f'{i+1}. {e}' for i, e in enumerate(plan.final_output.steps))}
    Cilj: {plan.final_output.objective}"""

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

Samopopravljajoči se agent

Načrtovanje ni dovolj: v realnem svetu orodja odpovejo. Druga oblika zanke omogoča agentu, da zazna lastne napake in jih popravi. Vse je odvisno od podrobnosti, ki jo pogosto spregledamo—orodje ne vrže izjeme; vrne berljivo sporočilo o napaki. Agent ga prebere, spozna, da je pozabil klavzulo FROM, prepiše svoj poizvedbo in poskusi znova, znotraj omejitve treh poskusov, določene v njegovih navodilih.

from agents import Agent, Runner, function_tool

@function_tool
def execute_sql_query(sql: str) -> str:
    """Izvede poizvedbo SQL na bazi podatkov."""
    # Simulacija: nekatere poizvedbe odpovejo
    if "DROP" in sql.upper():
        return "ERROR: Destructive queries are forbidden."
    if "SELECT" in sql.upper() and "FROM" not in sql.upper():
        return "ERROR: Invalid SQL syntax - missing 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="""Analiziraš podatke z izvajanjem poizvedb SQL.
    Če poizvedba ne uspe:
    1. Analiziraj sporočilo o napaki
    2. Popravi poizvedbo
    3. Poskusi znova
    Največ 3 poskusi na poizvedbo.
    Nikoli ne uporabi DROP, DELETE ali TRUNCATE.""",
    tools=[execute_sql_query],
    model="gpt-5.6-terra",
    max_turns=10,  # Dovolj obratov za popravke
)

result = Runner.run_sync(
    analyst_agent,
    "What is the total revenue by region?"
)

Opazi, da se prepoved destruktivnih poizvedb pojavi na dveh mestih: v navodilih in v kodi orodja. Navodila usmerjajo model, vendar le preverjanje na strani strežnika v orodju zagotavlja, da DROP TABLE nikoli ne uide.

Vzorec: veriga specializiranih agentov

Za kompleksne delovne tokove poveži več specializiranih agentov namesto obremenjevanja enega samega agenta z vso odgovornostjo. Vsak člen ima jasno vlogo: zbiralec zbere surov material, analitik—opremljen z modelom za razmišljanje—prepozna trende, pisec pa oblikuje izhod. Prednost je tako izobraževalna kot operativna: ko končno poročilo razočara, takoj veš, katerega od treh agentov moraš popraviti.

from agents import Agent, Runner

collection_agent = Agent(
    name="Data Collector",
    instructions="Zberi vse podatke, potrebne za analizo.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)

analysis_agent = Agent(
    name="Analyst",
    instructions="Analiziraj zbrane podatke in prepoznaj trende.",
    model="gpt-5.6-sol",  # Napredno razmišljanje za analizo
)

writing_agent = Agent(
    name="Writer",
    instructions="""Napiši jasno, strukturirano poročilo v angleščini
    na podlagi priložene analize. Oblika: uvod, ključne točke, priporočila.""",
    model="gpt-5.6-terra",
)

async def analysis_pipeline(question: str):
    # 1. korak: Zberi podatke
    data = await Runner.run(collection_agent, question)

    # 2. korak: Analiziraj
    analysis = await Runner.run(
        analysis_agent,
        f"Analyze this data: {data.final_output}"
    )

    # 3. korak: Napiši poročilo
    report = await Runner.run(
        writing_agent,
        f"Write a report based on this analysis: {analysis.final_output}"
    )

    return report.final_output

Nadzor globine razmišljanja

Vse te zanke imajo skupno lastnost: morda se nikoli ne ustavijo. Parameter max_turns je tvoja glavna zaščita in ga prilagajaš glede na ambicioznost naloge. Trije obrati zadostujejo za agenta, od katerega pričakuješ odgovor že ob prvem poskusu; petindvajset jih je potrebnih za raziskavo, ki poizveduje v več virih, preden pride do zaključka.

# Konzervativen agent: malo obratov
simple_agent = Agent(
    name="Simple Agent",
    instructions="Odgovori v enem obratu, če je mogoče.",
    model="gpt-5.6-terra",
)
result = await Runner.run(simple_agent, "Simple question", max_turns=3)

# Kompleksen agent: veliko obratov
research_agent = Agent(
    name="Deep Researcher",
    instructions="Razišči vse kote, preden prideš do zaključka.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)
result = await Runner.run(research_agent, "Complete Q1 analysis", max_turns=25)

To vrednost nastavi z opazovanjem svojih sledi, namesto da bi ugibal: če se tvoja dejanska izvajanja končajo v šestih obratih, omejitev petindvajset ne ščiti pred ničemer.

Ključne ugotovitve

  • Vzorec načrtuj-izvedi ločuje načrtovanje (model za razmišljanje) od izvajanja
  • Samopopravljajoči se agent analizira svoje napake in prilagodi strategijo
  • Verige specializiranih agentov omogočajo kompleksne, vzdrževane delovne tokove
  • max_turns nadzira globino razmišljanja in ščiti pred neskončnimi zankami
  • Napredne zmogljivosti razmišljanja prihrani za načrtovanje in analizo