Eksekvering på server vs. klient
På denne side
Lektionen opdateret 3. november 2026 baseret på
mistralaiSDK 3.7.0 og Mistral-dokumentationen om Handoffs: Enagent.handoff-post identificerer målagenten vianext_agent_id(ikketo_agent), ogconversations.appendaccepterer ikke enagent_id-parameter – ældre kode ville fejle. Genoptagelse af målagenten sker her via en ny samtale, hvor du sender konteksten videre. Kilder: Handoffs · client-python.
To måder at håndtere overdragelser på
Når en agent overfører kontrollen til en anden agent, tilbyder Mistral API to eksekveringstilstande: server (automatisk) og klient (manuel). Indstillingen er et enkelt ord, men den afgør, hvem der faktisk styrer arbejdsgangen. I server-tilstand delegerer du hele koreografien til Mistral og modtager resultatet. I klient-tilstand genvinder du kontrollen mellem hvert trin. Alt andet – agenterne, deres værktøjer, deres overdragelsesmål – forbliver præcis det samme.
Server-tilstand, standarden
response = client.beta.conversations.start(
agent_id=router_agent.id,
inputs="Analyze and calculate market trends.",
handoff_execution="server" # Standard — kan udelades
)
Flowet er fuldt styret: Routeren modtager anmodningen, beslutter at overføre til research-agenten, og Mistral udfører overførslen; research-agenten udfører sit arbejde og overfører derefter til calculatoren, og Mistral udfører også dette; calculatoren producerer resultatet. Du modtager det endelige svar ledsaget af alle mellemresultater – så du ser, hvad der skete, men i bagefter.
Denne tilstand har tre egenskaber, der forklarer, hvorfor den er standard. Den er enkel, da du ikke skriver nogen kontrollogik på din side. Den er hurtig, fordi hele kæden eksekveres hos Mistral uden netværks-roundtrips ved hvert relæ. Den er pålidelig, da fejlhåndtering og timeouts mellem agenter håndteres for dig.
Dens begrænsninger er den nøjagtige modpart. Du har ingen mellemkontrol: Det er umuligt at validere eller modificere en overdragelse, mens den sker. Omkostningerne er uigennemsigtige, idet alle agenter i kæden eksekveres, uden at du kan afbryde en anmodning midt i flowet, hvis den bevæger sig i en unødvendig retning. Og du kan ikke indsætte nogen brugerdefineret logik mellem trinnene – ingen finmasket logning, ingen validering, ingen forretningsbeslutninger.
Klient-tilstand, når du ønsker kontrol
response = client.beta.conversations.start(
agent_id=router_agent.id,
inputs="Analyze the cloud market.",
handoff_execution="client"
)
Routeren modtager anmodningen og beslutter at overføre, præcis som før. Men i stedet for at overførslen udføres, modtager du en agent.handoff-begivenhed, og kæden stopper der. Det er op til dig at genstarte den ved at kalde målagenten – hvilket giver dig frihed til at validere, logge, berige konteksten eller simpelthen nægte.
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}")
# Valider, og overdrag derefter til målagenten med nyttig kontekst
next_response = client.beta.conversations.start(
agent_id=target_agent_id,
inputs="Search for the latest tech news.",
)
# Behandl målagentens svar
for next_entry in next_response.outputs:
print(f"{next_entry.type}: {next_entry.content}")
Et punkt fortjener opmærksomhed: Mistral-dokumentationen beskriver client-tilstanden – hvor kontrollen returneres til dig ved overførselstidspunktet – men leverer ingen metode til at få målagenten til at genoptage den samme samtale, og conversations.append accepterer ikke en agent_id-parameter. Eksemplet starter derfor en samtale med målagenten, som du eksplicit sender det, de har brug for: den oprindelige anmodning og eventuelt et resumé af, hvad der allerede er gjort. Dette er også en mulighed for kun at sende det, de skal se.
Koden ovenfor håndterer kun ét relæ. En rigtig kæde forbinder flere, hvilket kræver en løkke.
def execute_with_control(router_id, query):
"""Udfører et multi-agent workflow med kontrol ved hvert trin."""
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] Overdragelse til {target}")
# Her kan du tilføje: validering, logning, metrikker
response = client.beta.conversations.start(
agent_id=target,
inputs=query, # den oprindelige anmodning, beriget hvis nødvendigt
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 ligner en pumpe: Så længe en overdragelse dukker op i outputs, behandler du den og genstarter; så snart en løkke-iteration ikke finder nogen, er kæden færdig, og du afslutter med de akkumulerede beskeder. Kommentaren i midten markerer det sted, der retfærdiggør hele denne tilstand: Det er her, og kun her, at din kode skyder sig ind mellem to agenter.
Valg mellem de to
Server-tilstand dækker standardproduktion. Hvis dit workflow er forudsigeligt, hvis du stoler på de agenter, du har skrevet, eller hvis du laver prototyper og hurtigt vil se resultater, er fuld automatisering det rigtige valg – og at skrive en kontrolsløjfe ville være spildt arbejde.
Klient-tilstand er berettiget, så snart et eksternt krav træder ind i kæden. Menneskelig validering, når en operatør skal godkende en overførsel til en agent, der udløser følsomme handlinger. Behov for logning og revision, når overholdelse kræver sporring af hvert trin med dine egne identifikatorer og dine egne tidsstempler. Betinget routing, når beslutningen afhænger af forretningsregler, som modellen ikke kan kende – kundestatus, tidspunkt på dagen, en kvote. En grænse eller rate-begrænsning, når du vil begrænse antallet af agenter, der eksekveres for en anmodning. Endelig en fallback-strategi, når én agents fejl skal udløse noget andet end en fejl, der vises til brugeren.
Sådan ser den første af disse situationer ud, reduceret til sit 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"Autoriser overførsel til {target}? (j/n) ")
if approval.lower() == "j":
response = client.beta.conversations.start(
agent_id=target,
inputs=query,
)
else:
print("Overførsel nægtet.")
break
Konsol-inputtet input tjener som demonstration; i en applikation vil det blive erstattet af en notifikation til en operatør og en genoptagelse af workflowet, når svaret ankommer. Princippet forbliver det samme: Overførslen sker kun, hvis din kode udløser den.
Den rigtige tilgang er at starte i server-tilstand og kun skifte den dag, en specifik begrænsning kræver det. At skifte til klient-tilstand “for en sikkerheds skyld” får dig straks til at betale prisen for kompleksiteten ved en løkke og netværks-roundtrips for en kontrol, du endnu ikke bruger.
Vigtige pointer
- Server-tilstand = fuldt automatisk, enkel og hurtig, ingen mellemkontrol
- Klient-tilstand = du modtager overdragelsesbegivenheder og beslutter, hvad du vil gøre
- Klient-tilstand muliggør validering, logning, betinget routing og fejlhåndtering
- I de fleste tilfælde er server-tilstand tilstrækkelig – skift til klient-tilstand, når du har brug for kontrol
- Begge tilstande understøtter de samme agentkæder; kun kontrollen adskiller sig