Vykonávanie na strane servera vs. klienta
Na tejto strane
Lekcia aktualizovaná 3. novembra 2026 na základe SDK
mistralai3.7.0 a dokumentácie Mistral Handoffs: položkaagent.handoffidentifikuje cieľového agenta prostredníctvomnext_agent_id(nieto_agent) aconversations.appendneprijíma parameteragent_id– starší kód by zlyhal. Obnovenie činnosti cieľového agenta tu prebieha cez novú konverzáciu, do ktorej odovzdáš kontext. Zdroje: Handoffs · client-python.
Dva spôsoby riešenia odovzdávania
Keď agent odovzdá riadenie inému agentovi, API Mistral ponúka dva režimy vykonávania: server (automatický) a client (manuálny). Toto nastavenie je len jedno slovo, no určuje, kto skutočne riadi pracovný postup. V režime server deleguješ celú choreografiu na Mistral a dostaneš výsledok. V režime klient získavaš kontrolu späť medzi jednotlivými krokmi. Všetko ostatné – agenti, ich nástroje, ich ciele odovzdania – zostáva úplne rovnaké.
Režim server, predvolená možnosť
response = client.beta.conversations.start(
agent_id=router_agent.id,
inputs="Analyze and calculate market trends.",
handoff_execution="server" # Predvolené – možno vynechať
)
Tok je plne spravovaný: smerovač dostane požiadavku, rozhodne sa odovzdať ju výskumnému agentovi a Mistral toto odovzdanie vykoná; výskumný agent odvedie svoju prácu a následne ju odovzdá kalkulačke, čo Mistral tiež vykoná; kalkulačka vyprodukuje výsledok. Dostaneš konečnú odpoveď sprevádzanou všetkými priebežnými výstupmi – vidíš teda, čo sa stalo, ale až dodatočne.
Tento režim má tri vlastnosti, ktoré vysvetľujú, prečo je predvolený. Je jednoduchý, keďže na svojej strane nepíšeš žiadnu riadiacu logiku. Je rýchly, pretože celý reťazec beží na strane Mistral bez sieťových spätných volaní pri každom prepoji. Je spoľahlivý, keďže ošetrenie chýb a časové limity medzi agentmi sú vybavené za teba.
Jeho obmedzenia sú presným opakom. Nemáš žiadnu priebežnú kontrolu: nie je možné validovať ani upravovať odovzdanie počas jeho priebehu. Náklady sú nepriehľadné v tom zmysle, že všetci agenti v reťazci vykonajú svoju úlohu bez toho, aby si mohol uprostred toku prerušiť požiadavku smerujúcu nepotrebným smerom. A nemôžeš vložiť žiadnu vlastnú logiku medzi kroky – žiadne podrobné logovanie, žiadna validácia, žiadne obchodné rozhodnutia.
Režim klient, keď potrebuješ kontrolu
response = client.beta.conversations.start(
agent_id=router_agent.id,
inputs="Analyze the cloud market.",
handoff_execution="client"
)
Smerovač dostane požiadavku a rozhodne sa ju odovzdať, presne ako predtým. Namiesto vykonania odovzdania však dostaneš udalosť agent.handoff a reťazec sa tam zastaví. Je len na tebe, aby si ho reštartoval zavolaním cieľového agenta – čo ti ponecháva priestor na validáciu, logovanie, obohatenie kontextu alebo jednoducho odmietnutie.
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}")
# Validuj a potom odovzdaj cieľovému agentovi s užitočným kontextom
next_response = client.beta.conversations.start(
agent_id=target_agent_id,
inputs="Search for the latest tech news.",
)
# Spracuj odpoveď cieľového agenta
for next_entry in next_response.outputs:
print(f"{next_entry.type}: {next_entry.content}")
Jeden bod si zaslúži pozornosť: dokumentácia Mistralu opisuje režim client – kontrola sa ti vráti v čase odovzdania –, ale neposkytuje metódu, aby cieľový agent pokračoval v tej istej konverzácii, a conversations.append neprijíma parameter agent_id. Príklad preto začína konverzáciu s cieľovým agentom, ktorému explicitne odovzdáš to, čo potrebuje: pôvodnú požiadavku a prípadne zhrnutie toho, čo už bolo vykonané. Je to tiež príležitosť odovzdať len to, čo musí vidieť.
Uvedený úryvok spracováva iba jedno prepojenie. Skutočný reťazec spája niekoľko agentov, čo si vyžaduje cyklus.
def execute_with_control(router_id, query):
"""Vykoná viacagentový pracovný postup s kontrolou v každom 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] Odovzdanie na {target}")
# Tu môžeš pridať: validáciu, logovanie, metriky
response = client.beta.conversations.start(
agent_id=target,
inputs=query, # pôvodná požiadavka, prípadne obohatená
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
Štruktúra funguje ako pumpa: kým sa vo výstupoch objaví odovzdanie, spracuješ ho a reštartuješ; hneď ako iterácia cyklu žiadne nenájde, reťazec je ukončený a ty vystúpiš s nahromadenými správami. Komentár v strede označuje miesto, ktoré odôvodňuje celý tento režim: práve tu a len tu sa tvoj kód vkladá medzi dvoch agentov.
Výber medzi oboma možnosťami
Režim server pokrýva štandardnú produkciu. Ak je tvoj pracovný postup predvídateľný, ak dôveruješ agentom, ktorých si napísal, alebo ak tvoríš prototyp a chceš rýchlo vidieť výsledky, plná automatizácia je správnou voľbou – a písanie riadiaceho cyklu by bolo plytvaním úsilím.
Režim klient je opodstatnený hneď, ako sa do reťazca zapojí externá požiadavka. Ľudská validácia, keď operátor musí schváliť odovzdanie agentovi, ktorý spúšťa citlivé akcie. Potreba logovania a auditu, keď súlad s predpismi vyžaduje sledovanie každého kroku s tvojimi vlastnými identifikátormi a časovými pečiatkami. Podmienené smerovanie, keď rozhodnutie závisí od obchodných pravidiel, ktoré model nemôže poznať – stav zákazníka, denná doba, kvóta. Obmedzenie alebo rate limiting, keď chceš ohraničiť počet agentov vykonaných pre jednu požiadavku. A nakoniec stratégia zálohy, keď zlyhanie jedného agenta musí spustiť niečo iné než chybu zobrazenú používateľovi.
Takto vyzerá prvá z týchto situácií, zredukovaná na svoju 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"Autorizovať odovzdanie na {target}? (y/n) ")
if approval.lower() == "y":
response = client.beta.conversations.start(
agent_id=target,
inputs=query,
)
else:
print("Odovzdanie zamietnuté.")
break
Konzolový príkaz input slúži ako demonštrácia; v aplikácii bude nahradený notifikáciou pre operátora a obnovením pracovného postupu po príchode odpovede. Princíp zostáva rovnaký: k odovzdaniu dôjde len vtedy, ak ho spustí tvoj kód.
Správnym prístupom je začať v režime server a prepnúť sa až v deň, keď si to vyžiada konkrétne obmedzenie. Prepnutie do režimu klient „pre istotu“ ťa okamžite pripraví o zložitosť cyklu a sieťových spätných volaní, za kontrolu, ktorú ešte nevyužívaš.
Kľúčové poznatky
- Režim server = plne automatický, jednoduchý a rýchly, žiadna priebežná kontrola
- Režim klient = dostávaš udalosti odovzdania a rozhoduješ, čo robiť ďalej
- Režim klient umožňuje validáciu, logovanie, podmienené smerovanie a ošetrenie chýb
- Pre väčšinu prípadov stačí režim server – prepnite na režim klient, keď potrebuješ kontrolu
- Oba režimy podporujú rovnaké reťazce agentov; líši sa len spôsob riadenia