Végrehajtás szerveren vagy kliensen
Ezen az oldalon
Lecke frissítve: 2026. november 3. a
mistralaiSDK 3.7.0 verziója és a Mistral Handoffs dokumentációja alapján: egyagent.handoffbejegyzés anext_agent_id(nem pedig ato_agent) segítségével azonosítja a célügynököt, és aconversations.appendnem fogad elagent_idparamé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