Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Több lépéses ügynök következtetési ciklussal

15. lecke 25 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Több lépéses ügynök következtetési ciklussal
  2. A tervezés-végrehajtás mintázat
  3. Önkorrigáló ügynök
  4. Mintázat: specializált ügynökök lánca
  5. A következtetés mélységének szabályozása
  6. Főbb megállapítások

Több lépéses ügynök következtetési ciklussal

A leghatékonyabb ügynökök nem állnak meg egyetlen eszközhívás után. Több következtetési lépést láncolnak össze, az eredmények alapján kiigazítják stratégiájukat, és addig iterálnak, amíg el nem érik a céljukat. Ebben a leckében megtanulod, hogyan építsd fel ezeket a több lépéses ügynököket. A példák a GPT-5.6 családot használják: míg az előző generációnál a következtetés engedélyezéséhez modellt kellett váltani, addig most a kiválasztott modellen belüli effort beállítással irányíthatod ezt a viselkedést.

A tervezés-végrehajtás mintázat

Egy több lépéses ügynök úgy kezd, hogy létrehoz egy tervet, majd végrehajtja az egyes lépéseket. Ez a szétválasztás szándékos: a tervezőnek nincsenek eszközei, és egy típusos struktúrát állít elő, míg a végrehajtó ezt a tervet kapja meg útitervként, és egyszerűen követi azt. Egy olyan homályos kérés, mint „készítsd elő a negyedéves értékelést a kulcsfontosságú ügyfelek számára“, konkrét cselekvések sorozatává válik – lekérdezés a CRM-ben, jelentés generálása, e-mail elküldése – még mielőtt bármilyen műveletet végrehajtanának.

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="""Komplex feladatot kapsz. Bontsd egyszerű, rendezett lépésekre.
    Minden lépésnek konkrét, végrehajtható elemnek kell lennie.""",
    model="gpt-5.6-sol",  # Haladó következtetés a tervezéshez
    output_type=PlanAction,
)

@function_tool
def search_crm(query: str) -> str:
    """Ügyfélinformációkat keres a CRM-ben."""
    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:
    """Formázott jelentést generál."""
    return f"Report '{title}' generated successfully ({len(content)} characters)"

@function_tool
def send_email(recipient: str, subject: str, body: str) -> str:
    """E-mailt küld."""
    return f"Email sent to {recipient}: {subject}"

executor_agent = Agent(
    name="Executor",
    instructions="""Lépésről lépésre hajtod végre a feladatokat.
    Használd a rendelkezésre álló eszközöket minden lépés teljesítéséhez.
    Ha egy lépés sikertelen, próbálj meg egy alternatív megközelítést.""",
    tools=[search_crm, generate_report, send_email],
    model="gpt-5.6-terra",
)

async def process_complex_task(task: str):
    # 1. lépés: Tervezés
    plan = await Runner.run(planner_agent, task)
    print(f"Plan: {plan.final_output.steps}")

    # 2. lépés: Végrehajtás a terv kontextusában
    execution_instructions = f"""Hajtsd végre a következő lépéseket sorrendben:
    {chr(10).join(f'{i+1}. {e}' for i, e in enumerate(plan.final_output.steps))}
    Célkitűzés: {plan.final_output.objective}"""

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

Önkorrigáló ügynök

A tervezés önmagában nem elég: a valóságban az eszközök meghibásodhatnak. A ciklusok második formája lehetővé teszi az ügynök számára, hogy felismerje saját hibáit és kijavítsa azokat. Minden egy gyakran figyelmen kívül hagyott részleten múlik: az eszköz nem dob kivételt, hanem egy olvasható hibaüzenetet ad vissza. Az ügynök elolvassa, rájön, hogy elfelejtette a FROM záradékot, átírja a lekérdezést, és újra megpróbálja – az utasításaiban meghatározott három próbálkozás keretein belül.

from agents import Agent, Runner, function_tool

@function_tool
def execute_sql_query(sql: str) -> str:
    """SQL lekérdezést hajt végre az adatbázison."""
    # Szimuláció: egyes lekérdezések sikertelenek
    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="""Adatokat elemzel SQL lekérdezések végrehajtásával.
    Ha egy lekérdezés sikertelen:
    1. Elemezd a hibaüzenetet
    2. Javítsd ki a lekérdezést
    3. Próbáld újra
    Lekérdezésenként maximum 3 próbálkozás.
    Soha ne használj DROP, DELETE vagy TRUNCATE parancsokat.""",
    tools=[execute_sql_query],
    model="gpt-5.6-terra",
    max_turns=10,  # Elég forduló a javításokhoz
)

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

Vedd észre, hogy a romboló lekérdezésekre vonatkozó tiltás két helyen is szerepel: az utasításokban és az eszköz kódjában. Az utasítás vezeti a modellt, de csak a szerveroldali ellenőrzés az eszközben garantálja, hogy egy DROP TABLE soha ne csússzon át a rendszeren.

Mintázat: specializált ügynökök lánca

Komplex munkafolyamatok esetén láncolj össze több specializált ügynököt ahelyett, hogy egyetlen ügynökre hárítanád az összes felelősséget. Minden láncszemnek világos szerepe van: a gyűjtő összegyűjti a nyersanyagot, az elemző – aki egy következtető modellel van felszerelve – azonosítja a trendeket, az író pedig formázza a kimenetet. Az előny egyszerre oktatási és működési jellegű: ha a végső jelentés csalódást kelt, azonnal tudod, melyik három ügynök közül kell javítanod.

from agents import Agent, Runner

collection_agent = Agent(
    name="Data Collector",
    instructions="Gyűjtsd össze az elemzéshez szükséges összes adatot.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)

analysis_agent = Agent(
    name="Analyst",
    instructions="Elemezd a gyűjtött adatokat és azonosítsd a trendeket.",
    model="gpt-5.6-sol",  # Haladó következtetés az elemzéshez
)

writing_agent = Agent(
    name="Writer",
    instructions="""Írj egy világos, strukturált jelentést angol nyelven
    a megadott elemzés alapján. Formátum: bevezetés, kulcspontok, ajánlások.""",
    model="gpt-5.6-terra",
)

async def analysis_pipeline(question: str):
    # 1. lépés: Adatgyűjtés
    data = await Runner.run(collection_agent, question)

    # 2. lépés: Elemzés
    analysis = await Runner.run(
        analysis_agent,
        f"Analyze this data: {data.final_output}"
    )

    # 3. lépés: Jelentés írása
    report = await Runner.run(
        writing_agent,
        f"Write a report based on this analysis: {analysis.final_output}"
    )

    return report.final_output

A következtetés mélységének szabályozása

Ezeknek a ciklusoknak van egy közös tulajdonságuk: előfordulhat, hogy sosem állnak le. A max_turns paraméter az elsődleges biztonsági hálód, amelyet a feladat ambíciószintje alapján hangolsz. Három forduló elegendő egy olyan ügynöknek, amelytől elvárják, hogy első próbálkozásra válaszoljon; huszonötre van szükség egy olyan felderítéshez, amely több forrást is lekérdez, mielőtt következtetést vonna le.

# Konzervatív ügynök: kevés forduló
simple_agent = Agent(
    name="Simple Agent",
    instructions="Ha lehetséges, egyetlen fordulóban válaszolj.",
    model="gpt-5.6-terra",
)
result = await Runner.run(simple_agent, "Simple question", max_turns=3)

# Komplex ügynök: sok forduló
research_agent = Agent(
    name="Deep Researcher",
    instructions="Mielőtt következtetést vonnál le, tárd fel az összes szempontot.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)
result = await Runner.run(research_agent, "Complete Q1 analysis", max_turns=25)

Ezt az értéket ne tippeléssel, hanem a nyomkövetési adatok (traces) megfigyelésével állítsd be: ha a tényleges végrehajtások hat forduló alatt befejeződnek, akkor a huszonötös korlát semmit sem véd ki.

Főbb megállapítások

  • A tervezés-végrehajtás mintázat elválasztja a tervezést (következtető modell) a végrehajtástól
  • Egy önkorrigáló ügynök elemzi a hibáit és kiigazítja a stratégiáját
  • A specializált ügynökök lánca lehetővé teszi a komplex, karbantartható munkafolyamatokat
  • A max_turns szabályozza a következtetés mélységét és megvéd a végtelen ciklusoktól
  • A haladó következtetési képességeket tartsd fenn a tervezéshez és az elemzéshez