Pokročilé vzory
Na této stránce
Aktualizováno 3. listopadu 2026: Podřízený workflow dříve vracel
execution.output, což v SDKmistralaiverze 3.7.0 chybí. Výsledek se nyní čte zresults použitímwait_for_result=Truepro čekání na dokončení.
Mimo lineární workflowny
Doposud jsme se zabývali workflowny, které spouštějí aktivity sekvenčně. V praxi však reálné případy použití vyžadují sofistikovanější vzory: řetězení workflow, paralelní spouštění aktivit nebo složité podmíněné rozhodování. Tyto čtyři vzory – řetězení, pokračování, paralelismus a fan-out/fan-in – pokrývají téměř každou architekturu, kterou budeš potřebovat postavit.
Řetězení workflow
Workflow může spustit jiné workflow. Tato schopnost slouží dvěma odlišným cílům: rozdělení složité logiky na znovu použitelná podřízená workflow a obejití limitu 51 200 událostí na jedno spuštění, protože každé podřízené workflow získává vlastní rozpočet. Mechanismus spoléhá na aktivitu, což je jediné místo, kde může SDK legitimně provést síťový požadavek.
import mistralai.workflows as workflows
from mistralai.client import Mistral
@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
"""Spustí podřízené workflow a počká na jeho výsledek."""
client = Mistral()
execution = await client.workflows.execute_workflow_async(
workflow_identifier=workflow_name,
input=input_data,
wait_for_result=True, # čekání na výsledek podřízeného workflow
)
return execution.result
@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
# Krok 1: Sběr dat (vyhrazené podřízené workflow)
data = await launch_sub_workflow(
"data_collection",
{"sources": params["sources"]}
)
# Krok 2: Analýza (vyhrazené podřízené workflow)
analysis = await launch_sub_workflow(
"content_analysis",
{"data": data}
)
# Krok 3: Generování reportu (vyhrazené podřízené workflow)
report = await launch_sub_workflow(
"report_generation",
{"analysis": analysis, "format": params["format"]}
)
return report
Přínos přesahuje pouhou čitelnost: data_collection se stává samostatným workflow, testovatelným v izolaci a znovu použitelným jinými pipeline, s vlastními časovými limity a zásadami opakování.
Stejný mechanismus, aplikovaný na workflow, které volá samo sebe, vytváří vzor pokračování (continuation). Místo zpracování sta tisíc položek v jediném spuštění – což limit událostí zakazuje – workflow zpracuje dávku a zbytek deleguje na novou instanci.
@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
# Získání aktuální dávky
batch = await retrieve_batch(offset, batch_size)
if not batch["items"]:
# Všechny dávky zpracovány
return {"status": "completed", "total_processed": offset}
# Zpracování aktuální dávky
await process_batch(batch["items"])
# Spuštění další dávky prostřednictvím nového workflow
next_batch = await launch_sub_workflow(
"batch_processing",
{"offset": offset + batch_size}
)
return next_batch
Každé nové spuštění začíná s čistým žurnálem. Počet zpracovatelných položek se stává neomezeným, přičemž podmínkou ukončení je jednoduše prázdná dávka.
Paralelizace pomocí asyncio.gather
Když jsou na sobě různé aktivity nezávislé, není důvod je spouštět sekvenčně. asyncio.gather je odešle na platformu současně a celkový čas se přiblíží času nejpomalejší aktivity, nikoli součtu všech dohromady.
import asyncio
import mistralai.workflows as workflows
@workflows.activity()
async def analyze_source(url: str) -> dict:
"""Analyzuje datový zdroj."""
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:
# Spuštění všech analýz paralelně
results = await asyncio.gather(
*[analyze_source(url) for url in urls]
)
return {
"source_count": len(results),
"results": list(results)
}
Existuje však jedno upozornění: ve výchozím nastavení gather propaguje první encountered výjimku a přeruší celou sadu. Pokud analyzuješ čtyřicet externích zdrojů, stačí, aby byl jeden offline, a přijdeš o ostatních třicet devět. Parametr return_exceptions=True toto chování změní: chyby jsou vráceny jako běžné hodnoty a je na tobě, abys je zpracoval.
@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# return_exceptions=True zabrání tomu, aby jedna chyba zablokovala ostatní
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)
}
Tento workflow vrací částečný výsledek doprovázený mírou úspěšnosti, což umožňuje downstream procesům rozhodnout, zda je kvalita dostatečná, nebo zda je potřeba opakování.
Rozhodování ve workflow
Složité větvení není pouze povoleno, ale často je hlavním důvodem použití workflow, za předpokladu, že podmínky vycházejí z výsledků aktivit. Případ moderování obsahu toto kaskádové logiku dobře ilustruje: automatické rozhodnutí, když je model vysoce přesvědčený, druhý názor při střední důvěře a eskalace na člověka v případě neshody nebo nízké důvěry.
@workflows.workflow.define(name="content_moderation")
class ContentModeration:
@workflows.workflow.entrypoint
async def run(self, content: dict) -> dict:
# Krok 1: Automatická analýza
analysis = await auto_analyze_content(content["text"])
if analysis["confidence_score"] > 0.95:
# Vysoká důvěra: automatické rozhodnutí
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:
# Střední důvěra: druhá analýza s jiným modelem
second_analysis = await analyze_content_model_b(content["text"])
if analysis["category"] == second_analysis["category"]:
# Obě modely se shodují
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:
# Neshoda: eskalace na člověka
await escalate_moderation(content["id"], analysis, second_analysis)
return {"decision": "pending", "method": "human_escalation"}
else:
# Nízká důvěra: přímá eskalace
await escalate_moderation(content["id"], analysis, None)
return {"decision": "pending", "method": "human_escalation"}
Všimni si pole method vráceného v každém bodě ukončení: umožňuje ti zpětně měřit, jaká část obsahu byla zpracována bez zásahu člověka, a podle toho upravovat prahové hodnoty.
Fan-out / Fan-in
Poslední vzor kombinuje předchozí: distribuce práce paralelně a následná agregace výsledků v jediném bodě. Zde je dokument současně přeložen do tří jazyků, každý překlad je paralelně analyzován a vše konverguje do shrnutí.
@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
@workflows.workflow.entrypoint
async def run(self, document: dict) -> dict:
# Fan-out: paralelní překlad do 3 jazyků
translations = await asyncio.gather(
translate(document["text"], "en"),
translate(document["text"], "de"),
translate(document["text"], "es")
)
# Fan-out: paralelní analýza každého překladu
analyses = await asyncio.gather(
*[analyze_sentiment(trad["translated_text"]) for trad in translations]
)
# Fan-in: agregace výsledků
summary = await aggregate_analyses(list(analyses))
return summary
Obě vlny paralelismu jsou po sobě jdoucí, protože druhá závisí na výsledcích první. V přísné sekvenci by tento workflow vyžadoval sedm řetězených volání; zde stojí pouze tři kroky orchestrace.
Stručně řečeno: rozděl složité workflowny na znovu použitelná podřízená workflow, paralelizuj, kdykoli jsou aktivity nezávislé, povol return_exceptions=True, když jsou částečné selhání přijatelná, měj vzor pokračování v záloze pro velmi dlouhé úlohy zpracování a vždy se ujisti, že tvé větvení spoléhá na výsledky aktivit, nikoli na nedeterministické hodnoty.
Klíčové poznatky
- Workflow může spouštět jiná workflow prostřednictvím aktivity, která volá SDK
- Vzor pokračování (continuation) umožňuje zpracovávat neomezený počet položek v postupných dávkách
asyncio.gatherti umožňuje spouštět aktivity paralelně a snížit tak celkový čas- Složité podmíněné větvení je podporováno, pokud závisí na výsledcích aktivit
- Vzor fan-out / fan-in distribuuje práci a následně agreguje výsledky