Avancerade mönster
På denna sida
Uppdaterad 3 november 2026: Underflödet returnerade tidigare
execution.output, vilket saknas imistralaiSDK 3.7.0. Resultatet läses nu frånresult, med hjälp avwait_for_result=Trueför att vänta på slutförande.
Utöver linjära arbetsflöden
Hittills har vi tittat på arbetsflöden som kör aktiviteter sekventiellt. I praktiken kräver verkliga användningsfall mer sofistikerade mönster: kedjekoppling av arbetsflöden, parallell körning av aktiviteter eller komplexa villkorliga beslut. Dessa fyra mönster – kedjekoppling, fortsättning, parallellism och fan-out/fan-in – täcker nästan alla arkitekturer du behöver bygga.
Kedjekoppling av arbetsflöden
Ett arbetsflöde kan trigga ett annat arbetsflöde. Denna funktionality tjänar två distinkta mål: att bryta ner komplex logik i återanvändbara underflöden och att kringgå gränsen på 51 200 händelser per exekvering, eftersom varje barnarbetsflöde får sin egen kvot. Mekanismen förlitar sig på en aktivitet, vilket är den enda plats där SDK:t legitimt kan göra ett nätverksanrop.
import mistralai.workflows as workflows
from mistralai.client import Mistral
@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
"""Startar ett barnarbetsflöde och väntar på dess resultat."""
client = Mistral()
execution = await client.workflows.execute_workflow_async(
workflow_identifier=workflow_name,
input=input_data,
wait_for_result=True, # vänta på resultatet från barnarbetsflödet
)
return execution.result
@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
# Steg 1: Datainsamling (dedikerat underflöde)
data = await launch_sub_workflow(
"data_collection",
{"sources": params["sources"]}
)
# Steg 2: Analys (dedikerat underflöde)
analysis = await launch_sub_workflow(
"content_analysis",
{"data": data}
)
# Steg 3: Rapportgenerering (dedikerat underflöde)
report = await launch_sub_workflow(
"report_generation",
{"analysis": analysis, "format": params["format"]}
)
return report
Fördelen går bortom enkel läsbarhet: data_collection blir ett fristående arbetsflöde, testbart i isolering och återanvändbart av andra pipelines, med egna tidsgränser och policyer för försök.
Samma mekanism, applicerad på ett arbetsflöde som anropar sig självt, skapar fortsättningsmönstret. Istället för att bearbeta hundratusentals objekt i en enda exekvering – vilket händelsegränsen förbjuder – bearbetar arbetsflödet en batch och delegerar resten till en ny instans.
@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
# Hämta aktuell batch
batch = await retrieve_batch(offset, batch_size)
if not batch["items"]:
# Alla batchar bearbetade
return {"status": "completed", "total_processed": offset}
# Bearbeta aktuell batch
await process_batch(batch["items"])
# Starta nästa batch via ett nytt arbetsflöde
next_batch = await launch_sub_workflow(
"batch_processing",
{"offset": offset + batch_size}
)
return next_batch
Varje ny exekvering startar med en ren journal. Antalet bearbetningsbara objekt blir obegränsat, där stoppvillkoret helt enkelt är en tom batch.
Parallellisering med asyncio.gather
När flera aktiviteter är oberoende av varandra finns det ingen anledning att köra dem i sekvens. asyncio.gather skickar dem till plattformen samtidigt, och den totala tiden närmar sig den för den långsammaste aktiviteten snarare än summan av alla.
import asyncio
import mistralai.workflows as workflows
@workflows.activity()
async def analyze_source(url: str) -> dict:
"""Analyserar en datakälla."""
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:
# Starta alla analyser parallellt
results = await asyncio.gather(
*[analyze_source(url) for url in urls]
)
return {
"source_count": len(results),
"results": list(results)
}
En varning gäller dock: som standard propagerar gather det första undantaget som uppstår och avbryter hela uppsättningen. Om du analyserar fyrtio externa källor leder bara en som är offline till att du förlorar de andra trettionio. Parametern return_exceptions=True ändrar detta beteende: fel returneras som vanliga värden, vilket lämnar åt dig att sortera ut dem.
@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# return_exceptions=True förhindrar att ett fel blockerar de andra
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)
}
Detta arbetsflöde returnerar ett delresultat åtföljt av en framgångsfrekvens, vilket låter nedströmsprocesser avgöra om kvaliteten är tillräcklig eller om ett nytt försök behövs.
Att fatta beslut i arbetsflödet
Komplex förgrening är inte bara tillåten utan ofta huvudpoängen med att använda arbetsflöden, förutsatt att villkoren härleds från aktivitetsresultat. Fallet med innehållsmoderering illustrerar denna kaskadlogik väl: automatiskt beslut när modellen är mycket säker, en andra åsikt när säkerheten är måttlig och eskalering till människa vid oenighet eller låg säkerhet.
@workflows.workflow.define(name="content_moderation")
class ContentModeration:
@workflows.workflow.entrypoint
async def run(self, content: dict) -> dict:
# Steg 1: Automatisk analys
analysis = await auto_analyze_content(content["text"])
if analysis["confidence_score"] > 0.95:
# Hög säkerhet: automatiskt beslut
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:
# Måttlig säkerhet: andra analys med en annan modell
second_analysis = await analyze_content_model_b(content["text"])
if analysis["category"] == second_analysis["category"]:
# Båda modellerna är överens
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:
# Oenighet: eskalering till människa
await escalate_moderation(content["id"], analysis, second_analysis)
return {"decision": "pending", "method": "human_escalation"}
else:
# Låg säkerhet: direkt eskalering
await escalate_moderation(content["id"], analysis, None)
return {"decision": "pending", "method": "human_escalation"}
Lägg märke till fältet method som returneras vid varje exit-punkt: det låter dig i efterhand mäta vilken andel av innehållet som bearbetades utan mänsklig inblandning, och därmed justera tröskelvärdena därefter.
Fan-out / Fan-in
Det sista mönstret kombinerar de tidigare: distribuera arbete parallellt och samla sedan resultaten på en enda punkt. Här översätts ett dokument samtidigt till tre språk, varje översättning analyseras parallellt och allt konvergerar till en sammanfattning.
@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
@workflows.workflow.entrypoint
async def run(self, document: dict) -> dict:
# Fan-out: översätt parallellt till 3 språk
translations = await asyncio.gather(
translate(document["text"], "en"),
translate(document["text"], "de"),
translate(document["text"], "es")
)
# Fan-out: analysera varje översättning parallellt
analyses = await asyncio.gather(
*[analyze_sentiment(trad["translated_text"]) for trad in translations]
)
# Fan-in: sammanställ resultat
summary = await aggregate_analyses(list(analyses))
return summary
De två vågorna av parallellism är successiva eftersom den andra beror på resultaten från den första. I strikt sekvens skulle detta arbetsflöde kräva sju kedjade anrop; här kostar det bara tre orkestreringssteg.
Sammanfattningsvis: bryt ner komplexa arbetsflöden i återanvändbara underflöden, parallellisera när aktiviteter är oberoende, aktivera return_exceptions=True när partiella fel är tolererbara, håll fortsättningsmönstret i reserv för mycket långa bearbetningsjobb och se alltid till att din förgrening förlitar sig på aktivitetsresultat snarare än icke-deterministiska värden.
Viktiga punkter
- Ett arbetsflöde kan trigga andra arbetsflöden via en aktivitet som anropar SDK:t
- Mönstret fortsättning möjliggör bearbetning av ett obegränsat antal objekt i successiva batchar
asyncio.gatherlåter dig köra aktiviteter parallellt för att minska den totala tiden- Komplex villkorlig förgrening stöds så länge den beror på aktivitetsresultat
- Mönstret fan-out / fan-in distribuerar arbete och sammanställer sedan resultaten