Pokročilé vzory
Na tejto strane
Aktualizované 3. novembra 2026: Podpracovný tok predtým vracal
execution.output, čo v SDKmistralaiverzii 3.7.0 chýba. Výsledok sa teraz číta zresults použitímwait_for_result=Truena čakanie na dokončenie.
Mimo lineárnych pracovných tokov
Doteraz sme sa pozerali na pracovné toky, ktoré vykonávajú aktivity sekvenčne. V praxi si reálne prípady použitia vyžadujú sofistikovanejšie vzory: reťazenie pracovných tokov, paralelné spúšťanie aktivít alebo zložité podmienené rozhodovania. Tieto štyri vzory – reťazenie, pokračovanie, paralelizmus a fan-out/fan-in – pokrývajú takmer každú architektúru, ktorú budeš potrebovať vytvoriť.
Reťazenie pracovných tokov
Pracovný tok môže spustiť iný pracovný tok. Táto schopnosť slúži dvom odlišným cieľom: rozdeleniu zložitej logiky na opätovne použiteľné podpracovné toky a obídeniu limitu 51 200 udalostí na jedno vykonanie, keďže každý dcérsky pracovný tok dostáva vlastný rozpočet. Mechanizmus sa spolieha na aktivitu, čo je jediné miesto, kde môže SDK legitímne uskutočniť sieťové volanie.
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í dcérsky pracovný tok a počká na jeho výsledok."""
client = Mistral()
execution = await client.workflows.execute_workflow_async(
workflow_identifier=workflow_name,
input=input_data,
wait_for_result=True, # čakanie na výsledok dcérskeho pracovného toku
)
return execution.result
@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
# Krok 1: Zber dát (vyhradený podpracovný tok)
data = await launch_sub_workflow(
"data_collection",
{"sources": params["sources"]}
)
# Krok 2: Analýza (vyhradený podpracovný tok)
analysis = await launch_sub_workflow(
"content_analysis",
{"data": data}
)
# Krok 3: Generovanie správy (vyhradený podpracovný tok)
report = await launch_sub_workflow(
"report_generation",
{"analysis": analysis, "format": params["format"]}
)
return report
Prínos presahuje jednoduchú čitateľnosť: data_collection sa stáva samostatným pracovným tokom, testovateľným v izolácii a opätovne použiteľným inými pipeline, s vlastnými časovými limitmi a politikami opakovania.
Ten istý mechanizmus, aplikovaný na pracovný tok, ktorý volá sám seba, vytvára vzor pokračovania. Namiesto spracovania stotisíc položiek v jednom vykonaní – čo limit udalostí zakazuje – pracovný tok spracuje dávku a zvyšok deleguje na novú inštanciu.
@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ískanie aktuálnej dávky
batch = await retrieve_batch(offset, batch_size)
if not batch["items"]:
# Všetky dávky spracované
return {"status": "completed", "total_processed": offset}
# Spracovanie aktuálnej dávky
await process_batch(batch["items"])
# Spustenie ďalšej dávky cez nový pracovný tok
next_batch = await launch_sub_workflow(
"batch_processing",
{"offset": offset + batch_size}
)
return next_batch
Každé nové vykonanie začína s čistým žurnálom. Počet spracovateľných položiek sa stáva neobmedzeným, pričom podmienkou zastavenia je jednoducho prázdna dávka.
Paralelizácia pomocou asyncio.gather
Keď sú viaceré aktivity navzájom nezávislé, nie je dôvod spúšťať ich postupne. asyncio.gather ich odovzdá platforme súčasne a celkový čas sa približuje času najpomalšej aktivity, namiesto súčtu všetkých.
import asyncio
import mistralai.workflows as workflows
@workflows.activity()
async def analyze_source(url: str) -> dict:
"""Analyzuje zdroj dát."""
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:
# Spustenie všetkých analýz paralelne
results = await asyncio.gather(
*[analyze_source(url) for url in urls]
)
return {
"source_count": len(results),
"results": list(results)
}
Platí však jedno upozornenie: v predvolenom nastavení gather propaguje prvú encountered výnimku a preruší celú sadu. Ak analyzuješ štyridsať externých zdrojov, stačí, aby bol jeden offline, a stratíš výsledky ostatných tridsiatich deviatich. Parameter return_exceptions=True zmení toto správanie: chyby sa vrátia ako bežné hodnoty a je na tebe, aby si ich vytriedil.
@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# return_exceptions=True zabráni 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 pracovný tok vráti čiastočný výsledok sprevádzaný mierou úspešnosti, čo umožňuje downstream procesom rozhodnúť, či je kvalita dostatočná, alebo či je potrebné opakovanie.
Rozhodovanie v pracovnom toku
Zložité vetvenie nielenže je povolené, ale často je hlavným dôvodom používania pracovných tokov, za predpokladu, že podmienky vychádzajú z výsledkov aktivít. Prípad moderovania obsahu toto kaskádové logické konanie dobre ilustruje: automatické rozhodnutie, keď je model vysoko presvedčený, druhý názor pri strednej dôvere a eskalácia na človeka v prípade nezhody alebo nízkej dôvery.
@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ôvera: automatické rozhodnutie
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:
# Stredná dôvera: druhá analýza s iným modelom
second_analysis = await analyze_content_model_b(content["text"])
if analysis["category"] == second_analysis["category"]:
# Oba modely súhlasia
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:
# Nezhoda: eskalácia na človeka
await escalate_moderation(content["id"], analysis, second_analysis)
return {"decision": "pending", "method": "human_escalation"}
else:
# Nízka dôvera: priama eskalácia
await escalate_moderation(content["id"], analysis, None)
return {"decision": "pending", "method": "human_escalation"}
Všimni si pole method vrátené v každom bode ukončenia: umožňuje ti spätne merať, aká časť obsahu bola spracovaná bez zásahu človeka, a podľa toho upravovať prahové hodnoty.
Fan-out / Fan-in
Posledný vzor kombinuje predchádzajúce: rozdelí prácu paralelne a následne agreguje výsledky na jednom mieste. Tu sa dokument simultánne prekladá do troch jazykov, každý preklad sa analyzuje paralelne a všetko konverguje do súhrnu.
@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
@workflows.workflow.entrypoint
async def run(self, document: dict) -> dict:
# Fan-out: paralelný preklad do 3 jazykov
translations = await asyncio.gather(
translate(document["text"], "en"),
translate(document["text"], "de"),
translate(document["text"], "es")
)
# Fan-out: paralelná analýza každého prekladu
analyses = await asyncio.gather(
*[analyze_sentiment(trad["translated_text"]) for trad in translations]
)
# Fan-in: agregácia výsledkov
summary = await aggregate_analyses(list(analyses))
return summary
Dve vlny paralelizmu sú po sebe idúce, pretože druhá závisí od výsledkov prvej. V striktnej sekvencii by tento pracovný tok vyžadoval sedem reťazených volaní; tu stojí len tri kroky orchestrácie.
Zhrnutie: rozdeľ zložité pracovné toky na opätovne použiteľné podpracovné toky, paralelizuj vždy, keď sú aktivity nezávislé, povoľ return_exceptions=True, keď sú čiastočné zlyhania prípustné, maj vzor pokračovania v zálohe pre veľmi dlhé spracovateľské úlohy a vždy sa uisti, že tvoje vetvenie sa spolieha na výsledky aktivít, nie na nedeterministické hodnoty.
Kľúčové poznatky
- Pracovný tok môže spustiť iné pracovné toky prostredníctvom aktivity, ktorá volá SDK
- Vzor pokračovania umožňuje spracovať neobmedzený počet položiek v postupných dávkach
asyncio.gatherti umožňuje spúšťať aktivity paralelne na zníženie celkového času- Zložité podmienené vetvenie je podporované, pokiaľ závisí od výsledkov aktivít
- Vzor fan-out / fan-in rozdeľuje prácu a následne agreguje výsledky