Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Exekvering på server kontra klient

Lektion 14 av 18 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Två sätt att hantera överlämningar
  2. Serverläge, standardvalet
  3. Klientläge, när du vill ha kontroll
  4. Att välja mellan de två
  5. Viktiga punkter

Lektionen uppdaterad 3 november 2026 baserat på mistralai SDK 3.7.0 och Mistral-dokumentationen om Handoffs: en post agent.handoff identifierar målagenten via next_agent_id (inte to_agent), och conversations.append accepterar ingen parameter agent_id – äldre kod skulle misslyckas. Återupptagning hos målagenten sker här via en ny konversation dit du skickar kontexten. Källor: Handoffs · client-python.

Två sätt att hantera överlämningar

När en agent överför kontrollen till en annan agent erbjuder Mistral API två exekveringslägen: server (automatiskt) och client (manuellt). Inställningen är ett enda ord, men den avgör vem som egentligen styr arbetsflödet. I serverläge delegerar du hela koreografin till Mistral och tar emot resultatet. I klientläge återtar du kontrollen mellan varje steg. Allt annat – agenterna, deras verktyg, deras överlämningsmål – förblir exakt detsamma.

Serverläge, standardvalet

response = client.beta.conversations.start(
    agent_id=router_agent.id,
    inputs="Analyze and calculate market trends.",
    handoff_execution="server"  # Standard — kan utelämnas
)

Flödet hanteras helt automatiskt: routern tar emot begäran, beslutar att överföra till forskningsagenten, och Mistral exekverar överföringen; forskningsagenten utför sitt arbete och överför sedan till kalkylatorn, och Mistral exekverar även detta; kalkylatorn producerar resultatet. Du tar emot det slutgiltiga svaret, åtföljt av alla mellanliggande utdata – så du ser vad som hände, men i efterhand.

Detta läge har tre egenskaper som förklarar varför det är standard. Det är enkelt, eftersom du inte skriver någon kontrolllogik på din sida. Det är snabbt, eftersom hela kedjan exekveras hos Mistral utan nätverksroundtrips vid varje relay. Det är tillförlitligt, då felhantering och tidsgränser mellan agenter hanteras åt dig.

Begränsningarna är den exakta motsatsen. Du har ingen kontroll under processens gång: det är omöjligt att validera eller modifiera en överlämning medan den sker. Kostnaden är ogenomskinlig, i den meningen att alla agenter i kedjan exekveras utan att du kan avbryta en begäran mitt i flödet om den går i onödig riktning. Och du kan inte infoga någon anpassad logik mellan stegen – ingen finkornig loggning, ingen validering, inga affärsbeslut.

Klientläge, när du vill ha kontroll

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

Routern tar emot begäran och beslutar att överföra, precis som tidigare. Men istället för att överföringen exekveras, tar du emot en händelse agent.handoff och kedjan stannar där. Det är upp till dig att starta om den genom att anropa målagenten – vilket lämnar dig friheten att validera, logga, berika kontexten eller helt enkelt vägra.

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

        # Validera, och överlämna sedan till målagenten, med användbar kontext
        next_response = client.beta.conversations.start(
            agent_id=target_agent_id,
            inputs="Search for the latest tech news.",
        )

        # Bearbeta målagentens svar
        for next_entry in next_response.outputs:
            print(f"{next_entry.type}: {next_entry.content}")

En punkt förtjänar uppmärksamhet: Mistrals dokumentation beskriver läget client – kontrollen återgår till dig vid överföringstillfället – men tillhandahåller ingen metod för att låta målagenten återuppta samma konversation, och conversations.append accepterar ingen parameter agent_id. Exemplet startar därför en konversation med målagenten, till vilken du uttryckligen skickar vad de behöver: den ursprungliga begäran, och i förekommande fall en sammanfattning av vad som redan gjorts. Detta är också ett tillfälle att endast skicka det de måste se.

Kodsnutten ovan hanterar endast ett enda relay. En riktig kedja länkar flera, vilket kräver en loop.

def execute_with_control(router_id, query):
    """Exekverar ett arbetsflöde med flera agenter med kontroll vid varje steg."""
    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"[LOGG] Överlämning till {target}")

                # Här kan du lägga till: validering, loggning, mätvärden
                response = client.beta.conversations.start(
                    agent_id=target,
                    inputs=query,  # den ursprungliga begäran, berikad vid behov
                    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

Strukturen är den hos en pump: så länge en överlämning dyker upp i utdatan bearbetar du den och startar om; så snart en loop-iteration inte hittar någon, är kedjan klar och du avslutar med de ackumulerade meddelandena. Kommentaren i mitten markerar platsen som motiverar hela detta läge: det är där, och bara där, som din kod skjuter in sig mellan två agenter.

Att välja mellan de två

Serverläge täcker standardproduktion. Om ditt arbetsflöde är förutsägbart, om du litar på de agenter du har skrivit, eller om du prototypar och vill se resultat snabbt, är full automatisering rätt val – och att skriva en kontroll-loop skulle vara slöseri med effort.

Klientläge är motiverat så snart ett externt krav kommer in i kedjan. Människovalidering, när en operatör måste godkänna en överföring till en agent som utlöser känsliga åtgärder. Behov av loggning och granskning, när regelefterlevnad kräver spårning av varje steg med dina egna identifierare och dina egna tidsstämplar. Villkorlig routning, när beslutet beror på affärsregler som modellen inte kan känna till – kundstatus, tid på dygnet, en kvot. Ett tak, eller hastighetsbegränsning, när du vill begränsa antalet agenter som exekveras för en begäran. En reservstrategi, slutligen, när en agents misslyckande måste utlösa något annat än ett fel som visas för användaren.

Så här ser den första av dessa situationer ut, reducerad till sitt skelett.

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"Godkänn överföring till {target}? (j/n) ")

            if approval.lower() == "j":
                response = client.beta.conversations.start(
                    agent_id=target,
                    inputs=query,
                )
            else:
                print("Överföring nekad.")
                break

Konsolens input fungerar som demonstration; i en applikation kommer den att ersättas av en avisering till en operatör och av återupptagande av arbetsflödet när svaret kommer. Principen förblir densamma: överföringen sker endast om din kod utlöser den.

Rätt approach är att börja i serverläge och byta först den dag en specifik begränsning kräver det. Att byta till klientläge “för säkerhets skull” får dig att omedelbart betala priset för komplexiteten i en loop och nätverksroundtrips, för kontroll som du ännu inte använder.

Viktiga punkter

  • Serverläge = helt automatiskt, enkelt och snabbt, ingen kontroll under processens gång
  • Klientläge = du tar emot överlämningshändelser och bestämmer vad du ska göra
  • Klientläge möjliggör validering, loggning, villkorlig routning och felhantering
  • För de flesta fall räcker serverläge – byt till klientläge när du behöver kontroll
  • Båda lägena stöder samma agentkedjor; endast kontrollen skiljer sig