Vykdymas serveryje arba kliente
Šiame puslapyje
Pamoka atnaujinta 2026 m. lapkričio 3 d. pagal
mistralaiSDK 3.7.0 versiją ir „Mistral“ Handoffs dokumentaciją: įrašasagent.handoffnurodo tikslinį agentą pernext_agent_id(neto_agent), oconversations.appendnepriima parametroagent_id– senesnis kodas neveiktų. Tikslinio agento tęsimas čia vyksta naujo pokalbio metu, kuriam perduodate kontekstą. Šaltiniai: Handoffs · client-python.
Du perdavimų valdymo būdai
Kai agentas perduoda valdymą kitam agentui, „Mistral“ API siūlo du vykdymo režimus: serverio (automatinį) ir kliento (rankinį). Nustatymas yra vienas žodis, tačiau jis lemia, kas tiksliai valdo darbo eigą. Serverio režimu visą choreografiją deleguoji „Mistral“ ir gauni rezultatą. Kliento režimu atgauni kontrolę po kiekvieno žingsnio. Visa kita – agentai, jų įrankiai, jų perdavimo tikslai – lieka visiškai tokie patys.
Serverio režimas – numatytasis variantas
response = client.beta.conversations.start(
agent_id=router_agent.id,
inputs="Analyze and calculate market trends.",
handoff_execution="server" # Numatyta – galima praleisti
)
Eiga valdoma visiškai: maršrutizatorius gauna užklausą, nusprendžia perduoti tyrimų agentui, ir „Mistral“ įvykdo perdavimą; tyrimų agentas atlieka savo darbą, tada perduoda skaičiuotuvui, ir „Mistral“ tai taip pat įvykdo; skaičiuotuvas pateikia rezultatą. Tu gauni galutinį atsakymą, lydimą visų tarpinių išvesčių – tad matai, kas įvyko, bet jau post factum.
Šis režimas pasižymi trim savybėmis, kurios paaiškina, kodėl jis yra numatytasis. Jis paprastas, nes tavo pusėje nerašai jokios valdymo logikos. Jis greitas, nes visa grandinė vykdoma „Mistral“ be tinklo užklausų kiekviename perdavimo taške. Jis patikimas, nes klaidų apdorojimą ir laiko limitus tarp agentų „Mistral“ tvarko už tave.
Jo trūkumai yra tiksli šių privalumų priešybė. Neturi tarpinės kontrolės: neįmanoma patvirtinti ar pakeisti perdavimo jo vykimo metu. Kaina yra neaiški ta prasme, kad visi grandinės agentai vykdomi be galimybės nutraukti užklausos, judančios nereikalinga kryptimi, vykdymą viduryje eigos. Be to, negali įterpti jokios savo logikos tarp žingsnių – jokio detalizuoto žurnalavimo, jokio patvirtinimo, jokių verslo sprendimų.
Kliento režimas, kai nori kontrolės
response = client.beta.conversations.start(
agent_id=router_agent.id,
inputs="Analyze the cloud market.",
handoff_execution="client"
)
Maršrutizatorius gauna užklausą ir nusprendžia ją perduoti – lygiai taip pat, kaip ir anksčiau. Tačiau vietoj to, kad perdavimas būtų įvykdytas, tu gauni agent.handoff įvykį, ir grandinė čia sustoja. Tai nuo tavęs priklauso, ar ją paleisti iš naujo iškviečiant tikslinį agentą – tai palieka tau laisvę patvirtinti, įrašyti į žurnalą, praturtinti kontekstą arba tiesiog atsisakyti.
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}")
# Patvirtink, tada perduok tiksliniam agentui su reikiamu kontekstu
next_response = client.beta.conversations.start(
agent_id=target_agent_id,
inputs="Search for the latest tech news.",
)
# Apdorok tikslinio agento atsakymą
for next_entry in next_response.outputs:
print(f"{next_entry.type}: {next_entry.content}")
Vienas punktas nusipelno dėmesio: „Mistral“ dokumentacija aprašo client režimą – kontrolė grąžinama tau perdavimo metu – tačiau nepateikia metodo, kaip priversti tikslinį agentą tęsti tą patį pokalbį, be to, conversations.append nepriima parametro agent_id. Todėl pavyzdyje pradedamas pokalbis su tiksliniu agentu, kuriam aiškiai perduodi tai, ko jam reikia: originalią užklausą ir, jei taikoma, jau atlikto darbo santrauką. Tai taip pat proga perduoti tik tai, ką jis turi matyti.
Pirmiau pateiktas fragmentas apdoroja tik vieną perdavimą. Tikra grandinė sujungia kelis, todėl reikia ciklo.
def execute_with_control(router_id, query):
"""Vykdo kelių agentų darbo eigą su kontrole kiekviename žingsnyje."""
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}")
# Čia gali pridėti: patvirtinimą, žurnalavimą, metrikas
response = client.beta.conversations.start(
agent_id=target,
inputs=query, # originali užklausa, prireikus praturtinta
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
Struktūra primena siurblį: kol išvestyje atsiranda perdavimas, jį apdoroji ir paleidi iš naujo; kai tik ciklo iteracija jų neranda, grandinė baigta ir išeini su sukauptais pranešimais. Komentaras viduryje žymi vietą, kuri pateisina visą šį režimą: būtent ten, ir tik ten, tavo kodas įsiterpia tarp dviejų agentų.
Pasirinkimas tarp šių dviejų
Serverio režimas padengia standartinę gamybą. Jei tavo darbo eiga nuspėjama, jei pasitiki savo parašytais agentais arba jei kuriate prototipą ir nori greitai pamatyti rezultatus, visiškas automatizavimas yra tinkamas pasirinkimas – o valdymo ciklo rašymas būtų laiko švaistymas.
Kliento režimas pateisinamas, kai į grandinę įtraukiamas išorinis reikalavimas. Žmogaus patvirtinimas, kai operatorius turi patvirtinti perdavimą agentui, kuris vykdo jautrius veiksmus. Žurnalavimo ir audito poreikis, kai atitikties reikalavimai diktuoja kiekvieno žingsnio sekimą su savo identifikatoriais ir laiko žymomis. Sąlyginis maršrutizavimas, kai sprendimas priklauso nuo verslo taisyklių, kurių modelis negali žinoti – kliento statuso, paros laiko, kvotos. Ribojimas arba dažnio limitavimas, kai nori apriboti vienai užklausai vykdomų agentų skaičių. Galiausiai, atsarginė strategija, kai vieno agento gedimas turi sukelti ką kita, o ne klaidą, rodomą naudotojui.
Štai kaip atrodo pirmoji iš šių situacijų, sumažinta iki savo skeleto.
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
Konsolės input čia tarnauja kaip demonstracija; programoje ją pakeis pranešimas operatoriui ir darbo eigos tęsimas gavus atsakymą. Principas lieka tas pats: perdavimas įvyksta tik tada, kai jį suaktyvina tavo kodas.
Tinkamas požiūris – pradėti serverio režimu ir pereiti tik tada, kai konkretus apribojimas to pareikalaus. Perėjimas į kliento režimą „tik tuo atveju“ iškart apmokestina tave ciklo sudėtingumu ir tinklo užklausomis už kontrolę, kurios dar nenaudoji.
Svarbiausi punktai
- Serverio režimas = visiškai automatinis, paprastas ir greitas, be tarpinės kontrolės
- Kliento režimas = gauni perdavimo įvykius ir pats sprendži, ką daryti
- Kliento režimas leidžia atlikti patvirtinimą, žurnalavimą, sąlyginį maršrutizavimą ir klaidų apdorojimą
- Daugeliu atvejų pakanka serverio režimo – pereik prie kliento režimo, kai tau reikia kontrolės
- Abu režimai palaiko tas pačias agentų grandines; skiriasi tik valdymas