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

Végrehajtás szerveren vagy kliensen

14. lecke 18 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Az átadások kezelésének két módja
  2. Szerver mód, az alapértelmezett
  3. Kliens mód, amikor kontrollra van szükséged
  4. Döntés a kettő között
  5. Főbb megállapítások

Lecke frissítve: 2026. november 3. a mistralai SDK 3.7.0 verziója és a Mistral Handoffs dokumentációja alapján: egy agent.handoff bejegyzés a next_agent_id (nem pedig a to_agent) segítségével azonosítja a célügynököt, és a conversations.append nem fogad el agent_id paramétert – a régebbi kódok hibát okoznának. A célügynök folytatása itt egy új beszélgetésen keresztül történik, amelynek átadod a kontextust. Források: Handoffs · client-python.

Az átadások kezelésének két módja

Amikor egy ügynök átadja az irányítást egy másiknak, a Mistral API két végrehajtási módot kínál: szerver (automatikus) és kliens (kézi). A beállítás mindössze egy szó, mégis ez határozza meg, ki vezérli valójában a munkafolyamatot. Szerver módban az egész koreográfiát a Mistralra bízod, és csak az eredményt kapod meg. Kliens módban minden lépés után visszanyered az irányítást. Minden más – maguk az ügynökök, eszközeik, az átadás céljai – pontosan ugyanaz marad.

Szerver mód, az alapértelmezett

response = client.beta.conversations.start(
    agent_id=router_agent.id,
    inputs="Analyze and calculate market trends.",
    handoff_execution="server"  # Alapértelmezett — elhagyható
)

A folyamat teljesen menedzselt: az útválasztó fogadja a kérést, úgy dönt, átadja a kutatóügynöknek, és a Mistral hajtja végre az átadást; a kutatóügynök elvégzi a munkáját, majd átadja a számológépnek, amit a Mistral szintén végrehajt; a számológép előállítja az eredményt. Te a végső választ kapod meg, az összes közbenső kimenettel együtt – így látod, mi történt, de csak utólag.

Ennek a módnak három olyan tulajdonsága van, ami megmagyarázza, miért ez az alapértelmezett. Egyszerű, mivel semmilyen vezérlési logikát nem kell írnod a saját oldaladon. Gyors, mert az egész lánc a Mistralon fut, hálózati körutak nélkül minden egyes továbbításnál. Megbízható, mivel az ügynökök közötti hibakezelést és időtúllépéseket a rendszer intézi helyetted.

Korlátai pontosan ezek tükörképei. Nincs közbenső kontrollod: lehetetlen validálni vagy módosítani egy átadást menet közben. A költség átláthatatlan abban az értelemben, hogy a lánc összes ügynöke végrehajtódik anélkül, hogy megszakíthatnál egy felesleges irányba tartó kérést a folyamat közepén. És nem illeszthetsz be egyedi logikát a lépések közé – nincs finomhangolt naplózás, nincs validálás, nincs üzleti döntéshozatal.

Kliens mód, amikor kontrollra van szükséged

response = client.beta.conversations.start(
    agent_id=router_agent.id,
    inputs="Analyze the cloud market.",
    handoff_execution="client"
)

Az útválasztó fogadja a kérést és úgy dönt, továbbít, pontosan úgy, mint előbb. De az átadás végrehajtása helyett egy agent.handoff eseményt kapsz, és a lánc itt megáll. Rajtad múlik, hogy újraindítod-e a célügynök hívásával – ez lehetőséget ad arra, hogy validálj, naplózz, gazdagítsd a kontextust, vagy egyszerűen megtagadd a továbbítást.

response = client.beta.conversations.start(
    agent_id=router_agent.id,
    inputs="Search for the latest tech news.",
    handoff_execution="client"
)

for entry in response.outputs:
    if entry.type == "agent.handoff":
        target_agent_id = entry.next_agent_id
        print(f"Handoff requested to: {target_agent_id}")

        # Validálás, majd átadás a célügynöknek, hasznos kontextussal
        next_response = client.beta.conversations.start(
            agent_id=target_agent_id,
            inputs="Search for the latest tech news.",
        )

        # A célügynök válaszának feldolgozása
        for next_entry in next_response.outputs:
            print(f"{next_entry.type}: {next_entry.content}")

Egy pontra érdemes figyelni: a Mistral dokumentációja leírja a client módot – a kontroll az átadás pillanatában hozzád kerül –, de nem提供 módszert arra, hogy a célügynök ugyanabban a beszélgetésben folytassa a munkát, és a conversations.append nem fogad el agent_id paramétert. A példa ezért egy új beszélgetést indít a célügynökkel, akinek expliciten átadod, amire szüksége van: az eredeti kérést, és adott esetben egy összefoglalót arról, ami eddig történt. Ez arra is lehetőséget ad, hogy csak azt add át, amit látnia kell.

A fenti kódrészlet csak egyetlen továbbítást kezel. Egy valós lánc többet is összekapcsol, ami ciklust igényel.

def execute_with_control(router_id, query):
    """Többügynökes munkafolyamat végrehajtása lépésenkénti kontrollal."""
    response = client.beta.conversations.start(
        agent_id=router_id,
        inputs=query,
        handoff_execution="client"
    )

    conversation_id = response.conversation_id
    results = []

    while True:
        handoff_found = False

        for entry in response.outputs:
            if entry.type == "agent.handoff":
                handoff_found = True
                target = entry.next_agent_id
                print(f"[LOG] Átadás ide: {target}")

                # Ide illeszthetsz be: validálást, naplózást, metrikákat
                response = client.beta.conversations.start(
                    agent_id=target,
                    inputs=query,  # az eredeti kérés, szükség esetén gazdagítva
                    handoff_execution="client",
                )
                conversation_id = response.conversation_id
                break

            elif entry.type == "message.output":
                results.append(entry.content)

        if not handoff_found:
            break

    return results

A szerkezet egy szivattyúéhoz hasonlít: amíg átadás jelenik meg a kimenetekben, addig feldolgozod és újraindítod; amint egy ciklusiteráció nem talál ilyet, a lánc véget ért, és kilépsz a felhalmozott üzenetekkel. A középső megjegyzés jelöli azt a helyet, ami ezt az egész módot indokolja: itt, és csak itt avatkozik be a kódod két ügynök közé.

Döntés a kettő között

A szerver mód lefedi a szabványos éles környezeteket. Ha a munkafolyamatod kiszámítható, ha bízol az általad írt ügynökökben, vagy ha prototípust készítesz, és gyorsan látni akarod az eredményeket, a teljes automatizálás a helyes választás – és egy vezérlőciklus megírása pazarlás lenne.

A kliens mód akkor indokolt, ha külső követelmény lép be a láncba. Emberi validálás, amikor egy operátornak jóvá kell hagynia egy olyan ügynöknek történő átadást, amely érzékeny műveleteket indít el. Naplózási és auditálási igény, amikor a megfelelőség megköveteli, hogy minden lépést saját azonosítóiddal és időbélyegeiddel kövess nyomon. Feltételes útválasztás, amikor a döntés olyan üzleti szabályoktól függ, amelyeket a modell nem ismerhet – ügyfél státusza, napszak, kvóta. Korlátozás vagy sebességhatár, amikor korlátozni akarod egy kéréshez végrehajtott ügynökök számát. Végül pedig tartalék stratégia, amikor egy ügynök hibájának valami mást kell kiváltania, mintsem egy hibaüzenetet a felhasználó felé.

Íme, hogyan néz ki ezek közül az első, a csontvázára redukálva.

def workflow_with_validation(router_id, query):
    response = client.beta.conversations.start(
        agent_id=router_id,
        inputs=query,
        handoff_execution="client"
    )

    for entry in response.outputs:
        if entry.type == "agent.handoff":
            target = entry.next_agent_id
            approval = input(f"Jóváhagyod az átadást ide: {target}? (i/n) ")

            if approval.lower() == "i":
                response = client.beta.conversations.start(
                    agent_id=target,
                    inputs=query,
                )
            else:
                print("Átadás megtagadva.")
                break

A konzolos input csak demonstrációként szolgál; egy alkalmazásban ezt felváltja egy értesítés az operátor felé, és a munkafolyamat folytatása a válasz megérkezésekor. Az elv ugyanaz marad: az átadás csak akkor történik meg, ha a kódod kiváltja azt.

A helyes megközelítés az, hogy szerver módban kezdj, és csak akkor válts, amikor egy konkrét kényszerítő erő ezt megköveteli. A „biztonsági játékból“ történő váltás kliens módra azonnal megfizettet veled egy ciklus komplexitását és a hálózati körutakat, olyan kontrollért, amit még nem használsz.

Főbb megállapítások

  • Szerver mód = teljesen automatikus, egyszerű és gyors, nincs közbenső kontroll
  • Kliens mód = átadási eseményeket kapsz, és te döntöd el, mit teszel
  • A kliens mód lehetővé teszi a validálást, naplózást, feltételes útválasztást és hibakezelést
  • A legtöbb esetben a szerver mód elegendő – csak akkor válts kliens módra, ha kontrollra van szükséged
  • Mindkét mód támogatja ugyanazokat az ügynökláncokat; csak a kontroll különbözik