Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Provádění na serveru vs. na klientovi

Lekce 14 z 18 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Dva způsoby řešení předávání
  2. Režim server, výchozí volba
  3. Režim klient, když potřebuješ kontrolu
  4. Volba mezi oběma přístupy
  5. Klíčové poznatky

Lekce aktualizována 3. listopadu 2026 na základě SDK mistralai verze 3.7.0 a dokumentace Mistral Handoffs: položka agent.handoff identifikuje cílového agenta pomocí next_agent_id (nikoli to_agent) a conversations.append nepřijímá parametr agent_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í