Napredni vzorci
Na tej strani
Posodobljeno 3. novembra 2026: Podrejeno delovno okolje je prej vračalo
execution.output, kar v SDKmistralairazličice 3.7.0 manjka. Rezultat se zdaj bere izresult, pri čemer se za čakanje na zaključek uporabljawait_for_result=True.
Onkraj linearnih delovnih tokov
Do zdaj smo obravnavali delovne toke, ki dejavnosti izvajajo zaporedno. V praksi zahtevajo realni primeri uporabe bolj sofisticirane vzorce: veriženje delovnih tokov, vzporedno izvajanje dejavnosti ali sprejemanje kompleksnih pogojnih odločitev. Ti štirje vzorci – veriženje, nadaljevanje, vzporednost in razpršitev/zbiranje (fan-out/fan-in) – pokrivajo skoraj vsako arhitekturo, ki jo boste potrebovali.
Veriženje delovnih tokov
Delovni tok lahko sproži drug delovni tok. Ta zmožnost služi dvema različnima ciljema: razčlenitvi kompleksne logike na ponovno uporabna podrejena delovna okolja in obходу omejitve 51.200 dogodkov na izvedbo, saj vsako podrejeno delovno okolje prejme svoj lastni proračun. Mehanizem temelji na dejavnosti, ki je edino mesto, kjer lahko SDK zakonito opravi omrežni klic.
import mistralai.workflows as workflows
from mistralai.client import Mistral
@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
"""Launches a child workflow and waits for its result."""
client = Mistral()
execution = await client.workflows.execute_workflow_async(
workflow_identifier=workflow_name,
input=input_data,
wait_for_result=True, # wait for the child workflow result
)
return execution.result
@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
# Step 1: Data collection (dedicated sub-workflow)
data = await launch_sub_workflow(
"data_collection",
{"sources": params["sources"]}
)
# Step 2: Analysis (dedicated sub-workflow)
analysis = await launch_sub_workflow(
"content_analysis",
{"data": data}
)
# Step 3: Report generation (dedicated sub-workflow)
report = await launch_sub_workflow(
"report_generation",
{"analysis": analysis, "format": params["format"]}
)
return report
Prednost presega zgolj berljivost: data_collection postane samostojno delovno okolje, ki ga je mogoče testirati izolirano in ga ponovno uporabiti v drugih cevovodih, z lastnimi časovnimi omejitvami in pravilniki za ponovne poskuse.
Isti mehanizem, uporabljen za delovni tok, ki kliče samega sebe, ustvari vzorec nadaljevanja. Namesto obdelave sto tisoč elementov v eni sami izvedbi – kar omejitev dogodkov prepoveduje – delovni tok obdela paket in preostanek delegira novi 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
# Retrieve the current batch
batch = await retrieve_batch(offset, batch_size)
if not batch["items"]:
# All batches processed
return {"status": "completed", "total_processed": offset}
# Process the current batch
await process_batch(batch["items"])
# Launch the next batch via a new workflow
next_batch = await launch_sub_workflow(
"batch_processing",
{"offset": offset + batch_size}
)
return next_batch
Vsaka nova izvedba se začne z dnevnikom brez zgodovine. Število obdelljivih elementov postane neomejeno, pri čemer je ustavni pogoj preprosto prazen paket.
Vzporedno izvajanje z asyncio.gather
Ko so dejavnosti med seboj neodvisne, ni razloga, da bi jih izvajali zaporedno. asyncio.gather jih platformi predloži hkrati, skupni čas pa se približa času najpočasnejše dejavnosti in ne vsoti vseh.
import asyncio
import mistralai.workflows as workflows
@workflows.activity()
async def analyze_source(url: str) -> dict:
"""Analyzes a data source."""
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:
# Launch all analyses in parallel
results = await asyncio.gather(
*[analyze_source(url) for url in urls]
)
return {
"source_count": len(results),
"results": list(results)
}
Vendar velja ena opomba: privzeto gather posreduje prvo zaznano izjemo in prekine celoten niz. Če analiziraš štirideset zunanjih virov, ti že eden, ki je nedostopen, povzroči izgubo ostalih devetinštiridesetih. Parameter return_exceptions=True to vedenje spremeni: napake se vrnejo kot navadne vrednosti, tebi pa prepuščajo, da jih razvrstiš.
@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# return_exceptions=True prevents one error from blocking the others
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)
}
Ta delovni tok vrne delni rezultat skupaj s stopnjo uspešnosti, kar downstream procesom omogoča, da se odločijo, ali je kakovost zadostna ali je potreben ponovni poskus.
Sprejemanje odločitev v delovnem toku
Kompleksno razvejanje ni le dovoljeno, ampak je pogosto glavni razlog za uporabo delovnih tokov, pod pogojem, da pogoji izhajajo iz rezultatov dejavnosti. Primer moderacije vsebine dobro ponazarja to kaskadno logiko: samodejna odločitev, ko je model zelo prepričan, drugo mnenje pri zmerni prepričanosti in eskalacija na človeka v primeru nesoglasja ali nizke prepričanosti.
@workflows.workflow.define(name="content_moderation")
class ContentModeration:
@workflows.workflow.entrypoint
async def run(self, content: dict) -> dict:
# Step 1: Automatic analysis
analysis = await auto_analyze_content(content["text"])
if analysis["confidence_score"] > 0.95:
# High confidence: automatic decision
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:
# Moderate confidence: second analysis with a different model
second_analysis = await analyze_content_model_b(content["text"])
if analysis["category"] == second_analysis["category"]:
# Both models agree
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:
# Disagreement: human escalation
await escalate_moderation(content["id"], analysis, second_analysis)
return {"decision": "pending", "method": "human_escalation"}
else:
# Low confidence: direct escalation
await escalate_moderation(content["id"], analysis, None)
return {"decision": "pending", "method": "human_escalation"}
Opazi polje method, ki se vrne na vsaki izstopni točki: omogoča ti retrospektivno merjenje deleža vsebine, obdelane brez človeškega posredovanja, in s tem ustrezno prilagajanje pragov.
Razpršitev / Zbiranje (Fan-out / Fan-in)
Zadnji vzorec združuje prejšnje: delo razporedi vzporedno, nato pa rezultate zbere na enem mestu. Tu se dokument hkrati prevede v tri jezike, vsak prevod se vzporedno analizira in vse se združi v povzetek.
@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
@workflows.workflow.entrypoint
async def run(self, document: dict) -> dict:
# Fan-out: translate in parallel into 3 languages
translations = await asyncio.gather(
translate(document["text"], "en"),
translate(document["text"], "de"),
translate(document["text"], "es")
)
# Fan-out: analyze each translation in parallel
analyses = await asyncio.gather(
*[analyze_sentiment(trad["translated_text"]) for trad in translations]
)
# Fan-in: aggregate results
summary = await aggregate_analyses(list(analyses))
return summary
Oba valova vzporednosti sta zaporedna, saj drugi Depends od rezultatov prvega. V strogo zaporednem zaporedju bi ta delovni tok zahteval sedem verižnih klicev; tukaj stane le tri korake orkestracije.
Skratka, razčleni kompleksne delovne toke na ponovno uporabna podrejena delovna okolja, vzporedno izvajaj dejavnosti, kadar so neodvisne, omogoči return_exceptions=True, ko so delne napake sprejemljive, imej vzorec nadaljevanja v rezervi za zelo dolge obdelave in vedno zagotovi, da tvoje razvejanje temelji na rezultatih dejavnosti in ne na nedeterminističnih vrednostih.
Ključne ugotovitve
- Delovni tok lahko sproži druge delovne toke prek dejavnosti, ki kliče SDK
- Vzorec nadaljevanja omogoča obdelavo neomejenega števila elementov v zaporednih paketih
asyncio.gatherti omogoča vzporedno izvajanje dejavnosti za zmanjšanje skupnega časa- Kompleksno pogojno razvejanje je podprto, dokler je odvisno od rezultatov dejavnosti
- Vzorec razpršitve / zbiranja (fan-out / fan-in) razporedi delo in nato zbere rezultate