Изпълнение на сървър срещу клиент
На тази страница
Урокът е актуализиран на 3 ноември 2026 г. въз основа на
mistralaiSDK 3.7.0 и документацията на Mistral за Handoffs: записътagent.handoffидентифицира целевия агент чрезnext_agent_id(а неto_agent), аconversations.appendне приема параметърagent_id—по-стар код би се провалил. Възобновяването на целевия агент тук става чрез нов разговор, на който предавате контекста. Източници: Handoffs · client-python.
Два начина за обработка на предаването на контрол
Когато един агент предаде контрола на друг, API на Mistral предлага два режима на изпълнение: сървър (автоматичен) и клиент (ръчен). Настройката е една дума, но тя определя кой всъщност управлява работния поток. В сървърен режим възлагате цялата хореография на Mistral и получавате резултата. В клиентски режим си връщате контрола между всяка стъпка. Всичко останало—агентите, техните инструменти, техните цели за предаване—остава точно същото.
Сървърен режим, по подразбиране
response = client.beta.conversations.start(
agent_id=router_agent.id,
inputs="Analyze and calculate market trends.",
handoff_execution="server" # Default — can be omitted
)
Потокът е напълно управляем: рутерът получава заявката, решава да я прехвърли към агента за проучване и Mistral изпълнява прехвърлянето; агентът за проучване върши работата си, след което я прехвърля към калкулатора и Mistral изпълнява и това; калкулаторът произвежда резултата. Вие получавате крайния отговор, придружен от всички междинни изходи—така виждате какво се е случило, но постфактум.
Този режим има три качества, които обясняват защо е по подразбиране. Той е прост, тъй като не пишете никаква логика за управление от ваша страна. Бърз е, защото цялата верига се изпълнява в Mistral без мрежови往返 (round-trips) при всяко реле. Надежден е, тъй като обработката на грешки и таймаутите между агентите се управляват вместо вас.
Неговите ограничения са точната противоположност. Нямате междинен контрол: невъзможно е да валидирате или модифицирате предаване, докато то се случва. Разходите са непрозрачни, в смисъл че всички агенти във веригата се изпълняват, без да можете да прекъснете по средата на потока заявка, насочена в ненужна посока. И не можете да вмъкнете никаква персонализирана логика между стъпките—няма фино гранулирано регистриране (logging), няма валидация, няма бизнес решения.
Клиентски режим, когато искате контрол
response = client.beta.conversations.start(
agent_id=router_agent.id,
inputs="Analyze the cloud market.",
handoff_execution="client"
)
Рутерът получава заявката и решава да я прехвърли, точно както преди. Но вместо прехвърлянето да се изпълни, вие получавате събитие agent.handoff и веригата спира дотам. Зависи от вас да я рестартирате, като извикате целевия агент—което ви оставя възможността да валидирате, регистрирате, обогатите контекста или просто да откажете.
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}")
Един момент заслужава внимание: документацията на Mistral описва режим client—контролът се връща при вас по време на прехвърляне—но не предоставя метод целевият агент да възобнови същия разговор, а conversations.append не приема параметър agent_id. Примерът следователно стартира разговор с целевия агент, на когото изрично предавате това, от което се нуждае: оригиналната заявка и, ако е приложимо, обобщение на вече свършеното. Това също е възможност да предадете само онова, което трябва да види.
Горният фрагмент обработва само едно реле. Реална верига свързва няколко, което изисква цикъл.
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
Структурата е тази на помпа: докато в изходите се появява предаване, вие го обработвате и рестартирате; щом една итерация на цикъла не открие такова, веригата е завършена и излизате с натрупаните съобщения. Коментарът в средата маркира мястото, което оправдава целия този режим: точно там и само там вашият код се намесва между два агента.
Избор между двете
Сървърният режим покрива стандартното производство. Ако вашият работен поток е предвидим, ако се доверявате на агентите, които сте написали, или ако правите прототип и искате бързо да видите резултати, пълната автоматизация е правилният избор—и писането на контролен цикъл би било загуба на усилия.
Клиентският режим е оправдан веднага щом във веригата влезе външно изискване. Човешка валидация, когато оператор трябва да одобри прехвърляне към агент, който задейства чувствителни действия. Необходимост от регистриране и одит, когато съответствието изисква проследяване на всяка стъпка с вашите собствени идентификатори и вашите собствени времеви марки. Условно насочване, когато решението зависи от бизнес правила, които моделът не може да знае—статус на клиент, време на деня, квота. Ограничение или ограничаване на честотата (rate limiting), когато искате да ограничите броя на изпълнените агенти за дадена заявка. Стратегия за възстановяване (fallback), най-накрая, когато неуспехът на един агент трябва да задейства нещо различно от грешка, показана на потребителя.
Ето как изглежда първата от тези ситуации, сведена до скелета си.
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
Конзолният input служи за демонстрация; в приложение той ще бъде заменен от известие до оператор и от възобновяване на работния поток, когато отговорът пристигне. Принципът остава същият: прехвърлянето се случва само ако вашият код го задейства.
Правилният подход е да започнете в сървърен режим и да превключите едва в деня, в който конкретно ограничение го изисква. Превключването към клиентски режим „за всеки случай“ ви кара веднага да платите за сложността на цикъл и мрежови往返, за контрол, който все още не използвате.
Ключови изводи
- Сървърен режим = напълно автоматичен, прост и бърз, без междинен контрол
- Клиентски режим = получавате събития за предаване и решавате какво да правите
- Клиентският режим позволява валидация, регистриране, условно насочване и обработка на грешки
- За повечето случаи сървърният режим е достатъчен—преминете към клиентски режим, когато имате нужда от контрол
- И двата режима поддържат едни и същи вериги от агенти; различава се само контролът