Provádění na serveru vs. na klientovi
Na této stránce
Lekce aktualizována 3. listopadu 2026 na základě SDK
mistralaiverze 3.7.0 a dokumentace Mistral Handoffs: položkaagent.handoffidentifikuje cílového agenta pomocínext_agent_id(nikolito_agent) aconversations.appendnepřijímá parametragent_id– starší kód by selhal. Obnovení činnosti cílového agenta zde probíhá prostřednictvím nové konverzace, do které předáte kontext. Zdroje: Handoffs · client-python.
Dva způsoby řešení předávání
Když jeden agent předá řízení jinému, API Mistral nabízí dva režimy provádění: server (automatický) a client (manuální). Toto nastavení je pouze jedno slovo, ale určuje, kdo skutečně řídí pracovní postup. V režimu server deleguješ celou choreografii na Mistral a obdržíš výsledek. V režimu klient získáváš kontrolu zpět mezi jednotlivými kroky. Všechno ostatní – agenti, jejich nástroje, jejich cíle předání – zůstává přesně stejné.
Režim server, výchozí volba
response = client.beta.conversations.start(
agent_id=router_agent.id,
inputs="Analyze and calculate market trends.",
handoff_execution="server" # Výchozí — lze vynechat
)
Tok je plně řízen: směrovač obdrží požadavek, rozhodne se pro předání výzkumnému agentovi a Mistral toto předání provede; výzkumný agent vykoná svou práci a poté předá řízení kalkulačce, což Mistral rovněž provede; kalkulačka vytvoří výsledek. Obdržíš konečnou odpověď doprovázenou všemi dílčími výstupy – vidíš tedy, co se stalo, ale až zpětně.
Tento režim má tři vlastnosti, které vysvětlují, proč je výchozí. Je jednoduchý, protože na své straně nepíšeš žádnou řídicí logiku. Je rychlý, protože celý řetězec běží na straně Mistralu bez síťových požadavků tam a zpět u každého předání. Je spolehlivý, protože zpracování chyb a časové limity mezi agenty jsou řešeny za tebe.
Jeho omezení jsou přesným opakem. Nemáš žádnou průběžnou kontrolu: není možné validovat nebo upravovat předání v okamžiku, kdy probíhá. Náklady jsou neprůhledné v tom smyslu, že všichni agenti v řetězci běží, aniž bys mohl uprostřed toku přerušit požadavek směřující nepotřebným směrem. A nemůžeš vložit žádnou vlastní logiku mezi kroky – žádné podrobné logování, žádnou validaci, žádná obchodní rozhodnutí.
Režim klient, když potřebuješ kontrolu
response = client.beta.conversations.start(
agent_id=router_agent.id,
inputs="Analyze the cloud market.",
handoff_execution="client"
)
Směrovač obdrží požadavek a rozhodne se pro předání, přesně jako dříve. Místo aby se však předání provedlo, obdržíš událost agent.handoff a řetězec se zde zastaví. Je na tobě, abys jej restartoval voláním cílového agenta – což ti ponechává prostor pro validaci, logování, obohacení kontextu, nebo prosté odmítnutí.
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}")
# Validace, poté předání cílovému agentovi s užitečným kontextem
next_response = client.beta.conversations.start(
agent_id=target_agent_id,
inputs="Search for the latest tech news.",
)
# Zpracování odpovědi cílového agenta
for next_entry in next_response.outputs:
print(f"{next_entry.type}: {next_entry.content}")
Jeden bod si zaslouží pozornost: dokumentace Mistralu popisuje režim client – kontrola se vrací tobě v okamžiku předání – ale neposkytuje žádnou metodu, jak by cílový agent pokračoval ve stejné konverzaci, a conversations.append nepřijímá parametr agent_id. Příklad proto zahajuje konverzaci s cílovým agentem, kterému explicitně předáš to, co potřebuje: původní požadavek a případně shrnutí toho, co již bylo provedeno. Je to také příležitost předat pouze to, co musí vidět.
Úryvek výše zpracovává pouze jedno předání. Skutečný řetězec jich spojuje několik, což vyžaduje cyklus.
def execute_with_control(router_id, query):
"""Provede víceagentový pracovní postup s kontrolou v každém kroku."""
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] Handoff to {target}")
# Zde můžeš přidat: validaci, logování, metriky
response = client.beta.conversations.start(
agent_id=target,
inputs=query, # původní požadavek, případně obohacený
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
Struktura funguje jako čerpadlo: dokud se ve výstupech objeví předání, zpracuješ jej a restartuješ; jakmile iterace cyklu žádné nenajde, řetězec je dokončen a ty skončíš s nahromaděnými zprávami. Komentář uprostřed označuje místo, které ospravedlňuje celý tento režim: právě zde a pouze zde se tvůj kód vkládá mezi dva agenty.
Volba mezi oběma přístupy
Režim server pokrývá standardní produkční nasazení. Pokud je tvůj pracovní postup předvídatelný, pokud věříš agentům, které jsi napsal, nebo pokud vytváříš prototyp a chceš rychle vidět výsledky, je plná automatizace správnou volbou – a psaní řídicího cyklu by bylo zbytečné úsilí.
Režim klient je opodstatněný, jakmile se do řetězce zapojí externí požadavek. Lidská validace, když operátor musí schválit předání agentovi, který spouští citlivé akce. Potřeba logování a auditu, když soulad s předpisy vyžaduje sledování každého kroku s tvými vlastními identifikátory a časovými razítky. Podmíněné směrování, když rozhodnutí závisí na obchodních pravidlech, která model nemůže znát – stav zákazníka, denní doba, kvóta. Omezení nebo rate limiting, když chceš omezit počet agentů spuštěných pro jeden požadavek. A nakonec strategie záložního řešení, když selhání jednoho agenta musí spustit něco jiného než chybu zobrazenou uživateli.
Zde je ukázka první z těchto situací, zredukovaná na samotnou kostru.
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"Authorize transfer to {target}? (y/n) ")
if approval.lower() == "y":
response = client.beta.conversations.start(
agent_id=target,
inputs=query,
)
else:
print("Transfer refused.")
break
Konzolové input slouží jako demonstrace; v aplikaci bude nahrazeno oznámením operátorovi a obnovením pracovního postupu po doručení odpovědi. Princip zůstává stejný: k předání dojde pouze tehdy, pokud jej spustí tvůj kód.
Správný přístup je začít v režimu server a přepnout se pouze v den, kdy to vyžaduje konkrétní omezení. Přechod na režim klient „pro jistotu“ tě okamžitě připraví o složitost cyklu a síťových požadavků tam a zpět, za kontrolu, kterou ještě nevyužíváš.
Klíčové poznatky
- Režim server = plně automatický, jednoduchý a rychlý, žádná průběžná kontrola
- Režim klient = obdržíš události předání a rozhoduješ, co dělat dál
- Režim klient umožňuje validaci, logování, podmíněné směrování a zpracování chyb
- Pro většinu případů stačí režim server – přepni na režim klient, když potřebuješ kontrolu
- Obě režimy podporují stejné řetězce agentů; liší se pouze řízení