Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Uitvoering op server versus client

Les 14 van 18 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Twee manieren om overdrachten af te handelen
  2. Servermodus, de standaard
  3. Clientmodus, wanneer u controle wilt
  4. Kiezen tussen de twee
  5. Belangrijkste punten

Les bijgewerkt op 3 november 2026 op basis van mistralai SDK 3.7.0 en de Mistral Handoffs-documentatie: een agent.handoff-vermelding identificeert de doelagent via next_agent_id (niet to_agent), en conversations.append accepteert geen agent_id-parameter—oudere code zou falen. Het hervatten van de doelagent gebeurt hier via een nieuw gesprek, waaraan u de context meegeeft. Bronnen: Handoffs · client-python.

Twee manieren om overdrachten af te handelen

Wanneer een agent de controle overdraagt aan een andere agent, biedt de Mistral API twee uitvoeringsmodi: server (automatisch) en client (handmatig). De instelling bestaat uit één woord, maar bepaalt wie de workflow daadwerkelijk aanstuurt. In de servermodus delegeert u de volledige choreografie aan Mistral en ontvangt u het resultaat. In de clientmodus krijgt u tussen elke stap de controle terug. Al het andere—de agenten, hun tools, hun overdrachtdoelen—blijft exact hetzelfde.

Servermodus, de standaard

response = client.beta.conversations.start(
    agent_id=router_agent.id,
    inputs="Analyze and calculate market trends.",
    handoff_execution="server"  # Default — can be omitted
)

De flow wordt volledig beheerd: de router ontvangt het verzoek, besluit over te dragen aan de research-agent, en Mistral voert de overdracht uit; de research-agent doet zijn werk en draagt vervolgens over aan de calculator, en Mistral voert ook dat uit; de calculator produceert het resultaat. U ontvangt de definitieve respons, vergezeld van alle tussenliggende outputs—u ziet dus wat er is gebeurd, maar achteraf.

Deze modus heeft drie kwaliteiten die verklaren waarom dit de standaard is. Het is eenvoudig, omdat u geen besturingslogica aan uw kant schrijft. Het is snel, omdat de volledige keten bij Mistral wordt uitgevoerd zonder netwerkround-trips bij elke relaisstap. Het is betrouwbaar, omdat foutafhandeling en time-outs tussen agenten voor u worden geregeld.

De beperkingen zijn het exacte tegenbeeld. U heeft geen tussenliggende controle: het is onmogelijk om een overdracht te valideren of aan te passen terwijl deze plaatsvindt. De kosten zijn ondoorzichtig, in die zin dat alle agenten in de keten worden uitgevoerd zonder dat u een verzoek dat een onnodige richting op gaat halverwege kunt onderbreken. En u kunt geen aangepaste logica tussen de stappen invoegen—geen fijnmazige logging, geen validatie, geen zakelijke beslissingen.

Clientmodus, wanneer u controle wilt

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

De router ontvangt het verzoek en besluit over te dragen, precies als eerder. Maar in plaats van dat de overdracht wordt uitgevoerd, ontvangt u een agent.handoff-gebeurtenis en stopt de keten daar. Het is aan u om deze te hervatten door de doelagent aan te roepen—dit laat u de ruimte om te valideren, te loggen, de context te verrijken, of simpelweg te weigeren.

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}")

        # Validate, then hand over to the target agent, with useful context
        next_response = client.beta.conversations.start(
            agent_id=target_agent_id,
            inputs="Search for the latest tech news.",
        )

        # Process the target agent's response
        for next_entry in next_response.outputs:
            print(f"{next_entry.type}: {next_entry.content}")

Eén punt verdient aandacht: de documentatie van Mistral beschrijft de client-modus—controle keert terug naar u op het moment van overdracht—maar biedt geen methode om de doelagent hetzelfde gesprek te laten hervatten, en conversations.append accepteert geen agent_id-parameter. Het voorbeeld start daarom een gesprek met de doelagent, aan wie u expliciet doorgeeft wat deze nodig heeft: het oorspronkelijke verzoek, en indien van toepassing een samenvatting van wat er al is gedaan. Dit is ook een kans om alleen door te geven wat deze moet zien.

Het fragment hierboven behandelt slechts één relais. Een echte keten verbindt er meerdere, wat vraagt om een lus.

def execute_with_control(router_id, query):
    """Executes a multi-agent workflow with control at each step."""
    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}")

                # Here you can add: validation, logging, metrics
                response = client.beta.conversations.start(
                    agent_id=target,
                    inputs=query,  # the original request, enriched if needed
                    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

De structuur is die van een pomp: zolang er een overdracht in de outputs verschijnt, verwerkt u deze en start u opnieuw; zodra een lusiteratie er geen vindt, is de keten voltooid en stopt u met de verzamelde berichten. De commentaarregel in het midden markeert de locatie die deze hele modus rechtvaardigt: het is daar, en alleen daar, dat uw code zich tussen twee agenten plaatst.

Kiezen tussen de twee

De servermodus dekt standaardproductie. Als uw workflow voorspelbaar is, als u vertrouwt op de agenten die u heeft geschreven, of als u prototypeert en snel resultaten wilt zien, dan is volledige automatisering de juiste keuze—en het schrijven van een controlemodule zou verspilde moeite zijn.

De clientmodus is gerechtvaardigd zodra een externe eis de keten binnenkomt. Menselijke validatie, wanneer een operator een overdracht moet goedkeuren naar een agent die gevoelige acties activeert. Een behoefte aan logging en auditing, wanneer compliance vereist dat elke stap wordt getraceerd met uw eigen identificatiecodes en uw eigen tijdstempels. Voorwaardelijke routing, wanneer de beslissing afhangt van bedrijfsregels die het model niet kan kennen—klantstatus, tijdstip, een quotum. Een limiet, of rate limiting, wanneer u het aantal uitgevoerde agenten voor een verzoek wilt begrenzen. Een fallback-strategie tot slot, wanneer het falen van één agent iets anders moet activeren dan een fout die aan de gebruiker wordt getoond.

Hier ziet u hoe de eerste van deze situaties eruitziet, teruggebracht tot zijn skelet.

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

De console-input dient als demonstratie; in een applicatie wordt deze vervangen door een melding aan een operator en door het hervatten van de workflow wanneer het antwoord binnenkomt. Het principe blijft hetzelfde: de overdracht vindt alleen plaats als uw code deze activeert.

De juiste aanpak is om te beginnen in de servermodus en alleen over te schakelen op de dag dat een specifieke beperking dit vereist. Overschakelen naar de clientmodus “voor het geval dat” laat u direct betalen voor de complexiteit van een lus en netwerkround-trips, voor controle die u nog niet gebruikt.

Belangrijkste punten

  • Servermodus = volledig automatisch, eenvoudig en snel, geen tussenliggende controle
  • Clientmodus = u ontvangt overdrachtgebeurtenissen en beslist wat u doet
  • Clientmodus maakt validatie, logging, voorwaardelijke routing en foutafhandeling mogelijk
  • Voor de meeste gevallen is de servermodus voldoende—schakel over naar de clientmodus wanneer u controle nodig heeft
  • Beide modi ondersteunen dezelfde agentenketens; alleen de controle verschilt