Täiustatud mustrid
Sellel lehel
Uuendatud 3. novembril 2026: Alamvoogude varem tagastatud
execution.outputpuudubmistralaiSDK versioonis 3.7.0. Tulemust loetakse nüüd väljaltresult, kasutades lõpuleviimise ootamiseks parameetritwait_for_result=True.
Lineaarsetest voogudest kaugemale
Seni oleme vaadelnud vooge, mis käivitavad tegevusi järjestikku. Praktikas nõuavad reaalsed kasutusjuhtumid keerukamaid mustreid: voogude aheldamine, tegevuste paralleelne käivitamine või keerukate tingimuslike otsuste tegemine. Need neli mustrit – aheldamine, jätkamine, paralleelsus ja fan-out/fan-in – katavad peaaegu kogu arhitektuuri, mida sul ehitamiseks vaja läheb.
Voogude aheldamine
Voog võib käivitada teise voo. See võimalus teenib kahte erinevat eesmärki: keeruka loogika lagundamine uuestikasutatavateks alamvoogudeks ja 51 200 sündmuse piirangu ületamine ühe täitmise kohta, kuna iga lapsvoog saab oma eelarve. Mehhanism tugineb tegevusele, mis on ainus koht, kus SDK saab seaduslikult võrgukutsu teha.
import mistralai.workflows as workflows
from mistralai.client import Mistral
@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
"""Käivitab lapsvoo ja ootab selle tulemust."""
client = Mistral()
execution = await client.workflows.execute_workflow_async(
workflow_identifier=workflow_name,
input=input_data,
wait_for_result=True, # oota lapsvoo tulemust
)
return execution.result
@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
# 1. samm: Andmete kogumine (spetsiaalne alamvoog)
data = await launch_sub_workflow(
"data_collection",
{"sources": params["sources"]}
)
# 2. samm: Analüüs (spetsiaalne alamvoog)
analysis = await launch_sub_workflow(
"content_analysis",
{"data": data}
)
# 3. samm: Aruande genereerimine (spetsiaalne alamvoog)
report = await launch_sub_workflow(
"report_generation",
{"analysis": analysis, "format": params["format"]}
)
return report
Kasu ei seisne ainult loetavuses: data_collection muutub iseseisvaks vooks, mida saab testida isoleeritult ja mida saavad kasutada teised torustikud, omades oma aegumisi ja uuestiproovimise poliitikaid.
Sama mehhanismi rakendamine voole, mis kutsub iseennast, loob jätkamise mustri. Ühe täitmise käigus saja tuhande elemendi töötlemise asemel – mida sündmuste piirang keelab – töötleb voog partii ja delegeerib ülejäänu uuele eksemplarile.
@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
# Haara praegune partii
batch = await retrieve_batch(offset, batch_size)
if not batch["items"]:
# Kõik partiid on töödeldud
return {"status": "completed", "total_processed": offset}
# Töötle praegune partii
await process_batch(batch["items"])
# Käivita järgmine partii uue voo kaudu
next_batch = await launch_sub_workflow(
"batch_processing",
{"offset": offset + batch_size}
)
return next_batch
Iga uus täitmine algab puhta ajakirjaga. Töödeldavate elementide arv muutub piiramatuks, kusjuures peatumistingimuseks on lihtsalt tühi partii.
Paralleelimine asyncio.gather abil
Kui mitu tegevust on üksteisest sõltumatud, pole mõtet neid järjestikku käivitada. asyncio.gather esitab need platvormile samaaegselt ja koguaeg läheneb aeglaseima tegevuse ajale, mitte kõigi tegevuste ajade summale.
import asyncio
import mistralai.workflows as workflows
@workflows.activity()
async def analyze_source(url: str) -> dict:
"""Analüüsib andmeallikat."""
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:
# Käivita kõik analüüsid paralleelselt
results = await asyncio.gather(
*[analyze_source(url) for url in urls]
)
return {
"source_count": len(results),
"results": list(results)
}
Siin kehtib aga üks hoiatus: vaikimisi levitab gather esimest tekkinud erindit ja katkestab kogu komplekti. Kui analüüsid neljakümmet välist allikat, põhjustab juba ühe offline olek teiste kolmekümne üheksa kaotuse. Parameeter return_exceptions=True muudab seda käitumist: vead tagastatakse tavaliste väärtustena, jättes sinu otsustada, kuidas nendega toime tulla.
@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# return_exceptions=True takistab ühel veal teisi blokeerimast
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)
}
See voog tagastab osalise tulemuse koos õnnestumise määraga, võimaldades järgnevatel protsessidel otsustada, kas kvaliteet on piisav või on vaja uuesti proovida.
Otsuste tegemine voos
Keerukas harudeks jagunemine pole mitte ainult lubatud, vaid on sageli voogude kasutamise peamine eesmärk, eeldusel, et tingimused tulenevad tegevuste tulemustest. Sisumoderatsiooni juhtum illustreerib seda kaskaadset loogikat hästi: automaatne otsus, kui mudel on väga kindel, teine arvamus mõõduka kindluse korral ja inimesele eskaleerimine lahkarvamuse või madala kindluse korral.
@workflows.workflow.define(name="content_moderation")
class ContentModeration:
@workflows.workflow.entrypoint
async def run(self, content: dict) -> dict:
# 1. samm: Automaatne analüüs
analysis = await auto_analyze_content(content["text"])
if analysis["confidence_score"] > 0.95:
# Kõrge kindlus: automaatne otsus
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õõdukas kindlus: teine analüüs teise mudeliga
second_analysis = await analyze_content_model_b(content["text"])
if analysis["category"] == second_analysis["category"]:
# Mõlemad mudelid on sama meelt
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:
# Lahkarvamus: eskaleerimine inimesele
await escalate_moderation(content["id"], analysis, second_analysis)
return {"decision": "pending", "method": "human_escalation"}
else:
# Madal kindlus: otsene eskaleerimine
await escalate_moderation(content["id"], analysis, None)
return {"decision": "pending", "method": "human_escalation"}
Pane tähele iga väljumispunktis tagastatud välja method: see võimaldab sul tagantjärele mõõta, milline osa sisust töödeldi ilma inimese sekkumiseta, ja seega vastavalt lävendeid kohandada.
Fan-out / Fan-in
Viimane muster ühendab eelmisi: jaga töö paralleelselt ja seejärel koonda tulemused ühes punktis. Siin tõlgitakse dokument samaaegselt kolme keelde, iga tõlget analüüsitakse paralleelselt ja kõik koondub kokkuvõtteks.
@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
@workflows.workflow.entrypoint
async def run(self, document: dict) -> dict:
# Fan-out: tõlgi paralleelselt 3 keelde
translations = await asyncio.gather(
translate(document["text"], "en"),
translate(document["text"], "de"),
translate(document["text"], "es")
)
# Fan-out: analüüsi iga tõlget paralleelselt
analyses = await asyncio.gather(
*[analyze_sentiment(trad["translated_text"]) for trad in translations]
)
# Fan-in: koonda tulemused
summary = await aggregate_analyses(list(analyses))
return summary
Kaks paralleelsuse lainet on järjestikused, kuna teine sõltub esimese tulemustest. Rangelt järjestikuses vormis nõuaks see voog seitset aheldatud kutset; siin maksab see vaid kolm orkestreerimissammu.
Kokkuvõtteks: lagunda keerukad voogudeks uuestikasutatavateks alamvoogudeks, paralleeli alati, kui tegevused on sõltumatud, lülita sisse return_exceptions=True, kui osalised ebaõnnestumised on talutavad, hoia jätkamine varuks väga pikkade töötlemistööde jaoks ja veendu alati, et sinu harudeks jagunemine tugineb tegevuste tulemustele, mitte mittedeterministlikele väärtustele.
Peamised punktid
- Voog saab käivitada teisi vooge tegevuse kaudu, mis kutsub SDK-d
- Jätkamise muster võimaldab töödelda piiramatut hulka elemente järjestikustes partiides
asyncio.gathervõimaldab käivitada tegevusi paralleelselt, et vähendada koguaega- Keerukas tingimuslik harudeks jagunemine on toetatud, kui see sõltub tegevuste tulemustest
- Fan-out / fan-in muster jagab töö ja koondab seejärel tulemused