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

Átadások: Több ügynök összehangolása

12. lecke 25 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Átadások: Több ügynök összehangolása
  2. Az átadás koncepciója
  3. Az átadás leírásának testreszabása
  4. Átadások kontextussal
  5. Mintázat: Háromszintű triázs
  6. Kétirányú átadások
  7. Az átadások nyomon követése
  8. Főbb megállapítások

Átadások: Több ügynök összehangolása

Egyetlen ügynök nem képes mindent elvégezni. Minél több domaint zsúfolsz bele egyetlen utasításkészletbe, annál inkább ellentmondanak egymásnak az irányelvek, és annál langyosabbak lesznek a válaszok. Az átadások (handoffs) lehetővé teszik, hogy egy ügynök delegálja a beszélgetést egy másik, specializált ügynöknek. Ez a kulcsmechanizmus a többügynökös rendszerek felépítéséhez, ahol minden ügynök a saját domainjében nyújt kiváló teljesítményt.

Az átadás koncepciója

Az átadás a vezérlés átadása egyik ügynökről a másikra. Amikor az A ügynök átadja a beszélgetést a B ügynöknek, a B ügynök veszi át az irányítást, és generálja a választ. A Runner automatikusan kezeli ezt az átmenetet: nem kell explicit útvonalválasztási logikát írnod, sem manuálisan meghívnod a második ügynököt. Az alábbi példában a triázs ügynök kap egy számlaösszeggel kapcsolatos panaszt, felismeri a domaint, és átadja a stafétát. A ügyfél eközben egyetlen folyamatos beszélgetést lát csak.

from agents import Agent, Runner

billing_agent = Agent(
    name="Billing Agent",
    instructions="""You handle billing questions: invoices, payments,
    refunds, subscriptions. Respond precisely and professionally.""",
    model="gpt-5.6-terra",
)

technical_agent = Agent(
    name="Technical Agent",
    instructions="""You handle technical support: bugs, configuration,
    installation, troubleshooting. Provide step-by-step instructions.""",
    model="gpt-5.6-terra",
)

triage_agent = Agent(
    name="Triage Agent",
    instructions="""You are the first point of contact.
    Analyze the customer's request and transfer it to the appropriate agent.
    - Billing questions → Billing Agent
    - Technical questions → Technical Agent""",
    handoffs=[billing_agent, technical_agent],
    model="gpt-5.6-terra",
)

result = Runner.run_sync(
    triage_agent,
    "My latest invoice seems incorrect; the amount is too high."
)
# The triage agent hands off to the billing agent
print(f"Answered by: {result.last_agent.name}")
print(result.final_output)

Az átadás leírásának testreszabása

Alapértelmezés szerint egy átadás a célügynök nevét és utasításait használja. Ez addig működik jól, amíg a nevek leíró jellegűek, de kockázatossá válik, ha két ügynök nagyon hasonlít egymásra. Ilyen esetekben testreszabhatod a leírást az útvonalválasztás irányításához, felsorolva azokat a specifikus forgatókönyveket, amelyeknek ki kell váltaniuk az egyes átadásokat.

from agents import Handoff

triage_agent = Agent(
    name="Triage Agent",
    instructions="Transfer the request to the specialized agent.",
    handoffs=[
        Handoff(
            agent=billing_agent,
            description="Transfer for payment questions, invoices, refunds, and subscriptions.",
        ),
        Handoff(
            agent=technical_agent,
            description="Transfer for technical issues, bugs, and configuration help requests.",
        ),
    ],
)

Átadások kontextussal

Egy átadás csak akkor hasznos, ha az átvevő ügynök tisztában van a helyzettel. Amikor egy ügynök átadást hajt végre, a beszélgetés előzményei továbbítódnak a célügynöknek: az új ügynök hozzáfér minden eddig elhangzotthoz, így az ügyfélnek nem kell megismételnie a problémáját. Ezen felül a típusozott kontextus strukturált munkamenet-adatokat szállít – ügyfélazonosító, előfizetési csomag, korábbi jegyek –, amelyek az érkező ügynök eszközei számára is elérhetőek maradnak.

from dataclasses import dataclass
from agents import Agent, Runner, RunContextWrapper, function_tool

@dataclass
class CustomerContext:
    client_id: str
    plan: str
    ticket_history: list[str]

@function_tool
def view_invoice(ctx: RunContextWrapper[CustomerContext], month: str) -> str:
    """Views the invoice for a given month for the current customer."""
    client_id = ctx.context.client_id
    return f"Invoice for {month} for {client_id}: €149.99 (plan {ctx.context.plan})"

billing_agent = Agent(
    name="Billing Agent",
    instructions="You handle billing. Use the customer context.",
    tools=[view_invoice],
    model="gpt-5.6-terra",
)

triage_agent = Agent(
    name="Triage",
    instructions="Transfer to the right agent.",
    handoffs=[billing_agent],
    model="gpt-5.6-terra",
)

context = CustomerContext(
    client_id="cli_456",
    plan="Pro",
    ticket_history=["Ticket #001: Slow connection"]
)

result = Runner.run_sync(
    triage_agent,
    "Can you check my invoice for March?",
    context=context,
)

Mintázat: Háromszintű triázs

Az átadások nem korlátozódnak a vízszintes útvonalválasztásra. Egy valódi ügyfélszolgálat eszkalációs struktúráját is képesek replikálni. Íme egy éles környezetben használt mintázat három szinttel: az L1 a rutinkéréseket kezeli, a haladó konfigurációs problémákat az L2-nek adja át, az L2 pedig az architektúrális témákat az L3-nak eszkalálja. Vegyed észre, hogy a harmadik szint egy képesebb modellt használ, mivel csak olyan eseteket lát, amelyeket az előző két szint már kiszűrt.

level3_agent = Agent(
    name="L3 Technical Expert",
    instructions="""You are a level 3 technical expert.
    You handle complex architecture and infrastructure problems.
    If you cannot resolve the issue, indicate that human escalation is necessary.""",
    model="gpt-5.6-sol",  # The most capable model for complex cases
)

level2_agent = Agent(
    name="L2 Technical Support",
    instructions="""You are a level 2 technician.
    You handle advanced configuration problems.
    If the problem is too complex, transfer to level 3.""",
    handoffs=[level3_agent],
    model="gpt-5.6-terra",
)

level1_agent = Agent(
    name="L1 Customer Support",
    instructions="""You are the first point of contact for customer support.
    Handle simple questions (password, account, navigation).
    Transfer technical problems to level 2.""",
    handoffs=[level2_agent],
    model="gpt-5.6-terra",
)

Kétirányú átadások

A lánc lehet körkörös is: két ügynök oda-vissza adhatja egymásnak a vezérlést. Ez akkor tipikus, amikor egy potenciális ügyfél technikai kérdést tesz fel egy értékesítési beszélgetés közben, majd megnyugtatva visszatér az árazáshoz.

sales_agent = Agent(
    name="Sales Agent",
    instructions="""You sell products. If the customer asks
    for technical support, transfer to the technical agent.""",
)

support_agent = Agent(
    name="Support Agent",
    instructions="""You provide technical support. If the customer
    wants to buy something, transfer to the sales agent.""",
)

# Bidirectional handoffs
sales_agent.handoffs = [support_agent]
support_agent.handoffs = [sales_agent]

Vigyázz a végtelen ciklusokkal: egy guardrail vagy a max_turns beállítása ajánlott. E korlát nélkül egy félreérthető kérés ide-oda pattinthatja a beszélgetést az egyik ügynökről a másikra, amíg el nem fogyasztod a kvótádat.

Az átadások nyomon követése

Végül tudnod kell, ki válaszolt valójában – mind az útvonalválasztás ellenőrzése, mind az ügyfélszolgálati statisztikák miatt. A RunResult megmondja, melyik ügynök állította elő végül a választ.

result = Runner.run_sync(triage_agent, "I have a critical bug")

print(f"Initial agent: triage_agent")
print(f"Final agent: {result.last_agent.name}")
# Prints "Technical Agent" if triage worked correctly

Szoktasd rá magad ennek az értéknek a naplózására: ha egy triázs ügynök megtartja azokat a kéréseket, amelyeket át kellett volna adnia, a last_agent eloszlása jóval az ügyfélvisszajelzések előtt feltárja a problémát.

Főbb megállapítások

  • Az átadások lehetővé teszik, hogy a beszélgetést egy specializált ügynöknek delegáld
  • A beszélgetés előzményei továbbítódnak a célügynöknek
  • Használd a Handoff(agent=..., description=...) szintaxist az útvonalválasztás irányításához
  • A megosztott kontextus (RunContextWrapper) minden ügynök számára elérhető
  • A result.last_agent.name jelzi, melyik ügynök válaszolt végül
  • Véd meg a kétirányú átadásokat a max_turns segítségével a ciklusok megelőzése érdekében