Разширени шаблони
На тази страница
Обновено на 3 ноември 2026 г.: Предишният подработен процес връщаше
execution.output, което липсва вmistralaiSDK версия 3.7.0. Резултатът вече се чете отresult, като се използваwait_for_result=True, за да се изчака приключването.
Отвъд линейните работни процеси
Досега разгледахме работни процеси, които изпълняват дейности последователно. На практика реалните случаи на употреба изискват по-усъвършенствани шаблони: свързване на работни процеси, паралелно изпълнение на дейности или вземане на сложни условни решения. Тези четири шаблона – верижно изпълнение, продължаване, паралелизъм и fan-out/fan-in – покриват почти всяка архитектура, която ще Ви се наложи да изградите.
Верижно свързване на работни процеси
Един работен процес може да стартира друг работен процес. Тази възможност служи на две различни цели: разбиване на сложна логика на многократни подработни процеси и заобикаляне на лимита от 51 200 събития на изпълнение, тъй като всеки дъщерен работен процес получава собствен бюджет. Механизмът разчита на дейност, която е единственото място, където SDK може легитимно да направи мрежово обаждане.
import mistralai.workflows as workflows
from mistralai.client import Mistral
@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
"""Стартира дъщерен работен процес и изчаква неговия резултат."""
client = Mistral()
execution = await client.workflows.execute_workflow_async(
workflow_identifier=workflow_name,
input=input_data,
wait_for_result=True, # изчакване на резултата от дъщерния работен процес
)
return execution.result
@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
# Стъпка 1: Събиране на данни (специализиран подработен процес)
data = await launch_sub_workflow(
"data_collection",
{"sources": params["sources"]}
)
# Стъпка 2: Анализ (специализиран подработен процес)
analysis = await launch_sub_workflow(
"content_analysis",
{"data": data}
)
# Стъпка 3: Генериране на отчет (специализиран подработен процес)
report = await launch_sub_workflow(
"report_generation",
{"analysis": analysis, "format": params["format"]}
)
return report
Ползата надхвърля простата четимост: data_collection се превръща в самостоятелен работен процес, който може да се тества изолирано и да се използва от други конвейери, със свои собствени политики за изчакване и повторни опити.
Същият механизъм, приложен към работен процес, който извиква самия себе си, създава шаблона за продължаване. Вместо да обработва сто хиляди елемента в едно изпълнение – което лимитът на събитията забранява – работният процес обработва партида и възлага останалите на нова инстанция.
@workflows.workflow.define(name="batch_processing")
class BatchProcessing:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
offset = params.get("offset", 0)
batch_size = 100
# Извличане на текущата партида
batch = await retrieve_batch(offset, batch_size)
if not batch["items"]:
# Всички партиди са обработени
return {"status": "completed", "total_processed": offset}
# Обработка на текущата партида
await process_batch(batch["items"])
# Стартиране на следващата партида чрез нов работен процес
next_batch = await launch_sub_workflow(
"batch_processing",
{"offset": offset + batch_size}
)
return next_batch
Всяко ново изпълнение започва с чист журнал. Броят на обработваемите елементи става неограничен, като условието за спиране е просто празна партида.
Паралелизиране с asyncio.gather
Когато множество дейности са независими една от друга, няма причина да се изпълняват последователно. asyncio.gather ги подава към платформата едновременно и общото време се доближава до това на най-бавната дейност, а не до сумата от всички тях.
import asyncio
import mistralai.workflows as workflows
@workflows.activity()
async def analyze_source(url: str) -> dict:
"""Анализира източник на данни."""
async with httpx.AsyncClient() as client:
response = await client.get(url)
return {"url": url, "size": len(response.text)}
@workflows.workflow.define(name="parallel_analysis")
class ParallelAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# Стартиране на всички анализи паралелно
results = await asyncio.gather(
*[analyze_source(url) for url in urls]
)
return {
"source_count": len(results),
"results": list(results)
}
Има обаче едно важно предупреждение: по подразбиране gather предава първата срещната грешка и прекъсва целия набор. Ако анализирате четиридесет външни източника, само един офлайн източник ще Ви накара да загубите останалите тридесет и девет. Параметърът return_exceptions=True променя това поведение: грешките се връщат като обикновени стойности, оставяйки Ви да ги сортирате.
@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# return_exceptions=True предотвратява блокирането на останалите от една грешка
results = await asyncio.gather(
*[analyze_source(url) for url in urls],
return_exceptions=True
)
successes = []
errors = []
for i, result in enumerate(results):
if isinstance(result, Exception):
errors.append({"url": urls[i], "error": str(result)})
else:
successes.append(result)
return {
"successes": successes,
"errors": errors,
"success_rate": len(successes) / len(urls)
}
Този работен процес връща частичен резултат, придружен от процент на успех, позволявайки на низходящите процеси да решат дали качеството е достатъчно или е необходим повторен опит.
Вземане на решения в работния процес
Сложното разклоняване не само е позволено, но често е основната причина за използването на работни процеси, стига условията да произлизат от резултатите от дейностите. Случаят с модерирането на съдържание илюстрира добре тази каскадна логика: автоматично решение, когато моделът е силно уверен; второ мнение при умерена увереност; и ескалация към човек в случай на несъгласие или ниска увереност.
@workflows.workflow.define(name="content_moderation")
class ContentModeration:
@workflows.workflow.entrypoint
async def run(self, content: dict) -> dict:
# Стъпка 1: Автоматичен анализ
analysis = await auto_analyze_content(content["text"])
if analysis["confidence_score"] > 0.95:
# Висока увереност: автоматично решение
if analysis["category"] == "acceptable":
await publish_content(content["id"])
return {"decision": "published", "method": "automatic"}
else:
await reject_content(content["id"], analysis["reason"])
return {"decision": "rejected", "method": "automatic"}
elif analysis["confidence_score"] > 0.7:
# Умерена увереност: втори анализ с различен модел
second_analysis = await analyze_content_model_b(content["text"])
if analysis["category"] == second_analysis["category"]:
# Двата модела са съгласни
if analysis["category"] == "acceptable":
await publish_content(content["id"])
return {"decision": "published", "method": "ai_consensus"}
else:
await reject_content(content["id"], analysis["reason"])
return {"decision": "rejected", "method": "ai_consensus"}
else:
# Несъгласие: ескалация към човек
await escalate_moderation(content["id"], analysis, second_analysis)
return {"decision": "pending", "method": "human_escalation"}
else:
# Ниска увереност: директна ескалация
await escalate_moderation(content["id"], analysis, None)
return {"decision": "pending", "method": "human_escalation"}
Обърнете внимание на полето method, върнато във всяка точка на изход: то Ви позволява ретроспективно да измерите каква част от съдържанието е обработено без човешка намеса и съответно да коригирате праговете.
Fan-out / Fan-in
Последният шаблон комбинира предишните: разпределете работата паралелно, след което агрегирайте резултатите в една точка. Тук документ се превежда едновременно на три езика, всеки превод се анализира паралелно и всичко се събира в обобщение.
@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
@workflows.workflow.entrypoint
async def run(self, document: dict) -> dict:
# Fan-out: превод паралелно на 3 езика
translations = await asyncio.gather(
translate(document["text"], "en"),
translate(document["text"], "de"),
translate(document["text"], "es")
)
# Fan-out: анализ на всеки превод паралелно
analyses = await asyncio.gather(
*[analyze_sentiment(trad["translated_text"]) for trad in translations]
)
# Fan-in: агрегиране на резултатите
summary = await aggregate_analyses(list(analyses))
return summary
Двете вълни на паралелизъм са последователни, защото втората зависи от резултатите на първата. При строга последователност този работен процес би изисквал седем верижни извиквания; тук той струва само три стъпки на оркестрация.
Обобщено казано: разбивайте сложните работни процеси на многократни подработни процеси, паралелизирайте винаги когато дейностите са независими, активирайте return_exceptions=True, когато частичните грешки са допустими, запазете шаблона за продължаване за много дълги задачи за обработка и винаги се уверявайте, че разклоняването Ви разчита на резултати от дейности, а не на недетерминирани стойности.
Ключови изводи
- Един работен процес може да стартира други работни процеси чрез дейност, която извиква SDK
- Шаблонът за продължаване позволява обработката на неограничен брой елементи в последователни партиди
asyncio.gatherВи позволява да изпълнявате дейности паралелно, за да намалите общото време- Сложното условно разклоняване се поддържа, стига да зависи от резултатите от дейностите
- Шаблонът fan-out / fan-in разпределя работата и след това агрегира резултатите