Pažangūs šablonai
Šiame puslapyje
Atnaujinta 2026 m. lapkričio 3 d.: Anksčiau sub-workflow grąžindavo
execution.output, kurio nebėramistralaiSDK 3.7.0 versijoje. Dabar rezultatas nuskaitymas išresult, naudojantwait_for_result=True, kad būtų laukiama užbaigimo.
Už tiesinių workflow ribų
Iki šiol nagrinėjome workflow, kurie vykdo veiklas nuosekliai. Praktikoje realūs panaudojimo atvejai reikalauja sudėtingesnių šablonų: workflow grandinių kūrimo, lygiagrečio veiklų vykdymo arba sudėtingų sąlyginių sprendimų priėmimo. Šie keturi šablonai – grandinė (chaining), tęstinumas (continuation), lygiagretumas (parallelism) ir išskaidymas/sujungimas (fan-out/fan-in) – apima beveik kiekvieną architektūrą, kurią tau reikės sukurti.
Workflow grandinės
Workflow gali inicijuoti kitą workflow. Ši galimybė tarnauja dviem skirtingiems tikslams: sudėtingos logikos suskaidymui į pakartotinai naudojamus sub-workflow ir 51 200 įvykių vienam vykdymui limito apeinimui, nes kiekvienas vaikinis workflow gauna savo biudžetą. Mechanizmas remiasi veikla – tai vienintelė vieta, kurioje SDK gali teisėtai atlikti tinklo užklausą.
import mistralai.workflows as workflows
from mistralai.client import Mistral
@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
"""Paleidžia vaikinį workflow ir laukia jo rezultato."""
client = Mistral()
execution = await client.workflows.execute_workflow_async(
workflow_identifier=workflow_name,
input=input_data,
wait_for_result=True, # laukiama vaikinio workflow rezultato
)
return execution.result
@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
# 1 žingsnis: Duomenų rinkimas (specializuotas sub-workflow)
data = await launch_sub_workflow(
"data_collection",
{"sources": params["sources"]}
)
# 2 žingsnis: Analizė (specializuotas sub-workflow)
analysis = await launch_sub_workflow(
"content_analysis",
{"data": data}
)
# 3 žingsnis: Ataskaitos generavimas (specializuotas sub-workflow)
report = await launch_sub_workflow(
"report_generation",
{"analysis": analysis, "format": params["format"]}
)
return report
Naudą teikia ne tik paprastesnis skaitomumas: data_collection tampa savarankišku workflow, kurį galima testuoti atskirai ir naudoti kituose pipeline, turinčiu savo laiko limitus ir kartojimo politikas.
Tas pats mechanizmas, pritaikytas workflow, kuris kviečia patį save, sukuria tęstinumo šabloną. Užuot apdorojus šimtą tūkstančių elementų vieno vykdymo metu – ko įvykių limitas neleidžia – workflow apdoroja grupę (batch) ir perduoda likusią dalį naujam egzemplioriui.
@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
# Gauti dabartinę grupę
batch = await retrieve_batch(offset, batch_size)
if not batch["items"]:
# Visos grupės apdorotos
return {"status": "completed", "total_processed": offset}
# Apdoroti dabartinę grupę
await process_batch(batch["items"])
# Paleisti kitą grupę per naują workflow
next_batch = await launch_sub_workflow(
"batch_processing",
{"offset": offset + batch_size}
)
return next_batch
Kiekvienas naujas vykdymas prasideda švariu žurnalu. Apdorojamų elementų skaičius tampa neribotas, o sustojimo sąlyga yra tiesiog tuščia grupė.
Lygiagretinimas naudojant asyncio.gather
Kai kelios veiklos yra nepriklausomos viena nuo kitos, nėra priežasties jų vykdyti nuosekliai. asyncio.gather jas vienu metu pateikia platformai, o bendras laikas artėja prie lėčiausios veiklos trukmės, o ne visų jų sumos.
import asyncio
import mistralai.workflows as workflows
@workflows.activity()
async def analyze_source(url: str) -> dict:
"""Analizuoja duomenų šaltinį."""
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:
# Paleisti visas analizes lygiagrečiai
results = await asyncio.gather(
*[analyze_source(url) for url in urls]
)
return {
"source_count": len(results),
"results": list(results)
}
Tačiau yra viena sąlyga: pagal nutylėjimą gather perduoda pirmąją aptiktą išimtį ir nutraukia visą rinkinį. Jei analizuoji keturiasdešimt išorinių šaltinių, vienam esant neprisijungusiam, prarandi likusius trisdešimt devynis. Parametras return_exceptions=True pakeičia šį elgesį: klaidos grąžinamos kaip įprastos reikšmės, paliekant tau teisę jas išsiaiškinti.
@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# return_exceptions=True neleidžia vienai klaidai blokuoti kitų
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)
}
Šis workflow grąžina dalinį rezultatą kartu su sėkmės rodikliu, leisdamas tolesniems procesams nuspręsti, ar kokybė yra pakankama, ar reikia kartoti.
Sprendimų priėmimas workflow metu
Sudėtingas šakojimasis yra ne tik leidžiamas, bet dažnai yra pagrindinė workflow naudojimo priežastis, su sąlyga, kad sąlygos kyla iš veiklų rezultatų. Turinio moderavimo atvejis gerai iliustruoja šią kaskadinę logiką: automatinis sprendimas, kai modelis labai įsitikinęs; antroji nuomonė, kai įsitikinimas vidutinis; ir perdavimas žmogui nesutapimo ar mažo įsitikinimo atveju.
@workflows.workflow.define(name="content_moderation")
class ContentModeration:
@workflows.workflow.entrypoint
async def run(self, content: dict) -> dict:
# 1 žingsnis: Automatinė analizė
analysis = await auto_analyze_content(content["text"])
if analysis["confidence_score"] > 0.95:
# Didelis įsitikinimas: automatinis sprendimas
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:
# Vidutinis įsitikinimas: antroji analizė su kitu modeliu
second_analysis = await analyze_content_model_b(content["text"])
if analysis["category"] == second_analysis["category"]:
# Abu modeliai sutaria
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:
# Nesutapimas: perdavimas žmogui
await escalate_moderation(content["id"], analysis, second_analysis)
return {"decision": "pending", "method": "human_escalation"}
else:
# Mažas įsitikinimas: tiesioginis perdavimas
await escalate_moderation(content["id"], analysis, None)
return {"decision": "pending", "method": "human_escalation"}
Atkreipk dėmesį į kiekviename išėjimo taške grąžinamą lauką method: jis leidžia retrospektyviai išmatuoti, kokia turinio dalis buvo apdorota be žmogaus įsikišimo, ir taip atitinkamai pakoreguoti slenkstines reikšmes.
Išskaidymas / Sujungimas (Fan-out / Fan-in)
Paskutinis šablonas sujungia ankstesnius: darbas paskirstomas lygiagrečiai, o tada rezultatai suvienijami viename taške. Čia dokumentas vienu metu verčiamas į tris kalbas, kiekvienas vertimas analizuojamas lygiagrečiai, ir viskas susilieja į santrauką.
@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
@workflows.workflow.entrypoint
async def run(self, document: dict) -> dict:
# Fan-out: versti lygiagrečiai į 3 kalbas
translations = await asyncio.gather(
translate(document["text"], "en"),
translate(document["text"], "de"),
translate(document["text"], "es")
)
# Fan-out: analizuoti kiekvieną vertimą lygiagrečiai
analyses = await asyncio.gather(
*[analyze_sentiment(trad["translated_text"]) for trad in translations]
)
# Fan-in: sujungti rezultatus
summary = await aggregate_analyses(list(analyses))
return summary
Dvi lygiagretumo bangos yra nuoseklios, nes antroji priklauso nuo pirmosios rezultatų. Griežtai nuosekliai vykdomas šis workflow reikalautų septynių grandininio tipo iškvietimų; čia tai kainuoja tik tris orchestracijos žingsnius.
Apibendrinant: suskaidyk sudėtingus workflow į pakartotinai naudojamus sub-workflow, lygiagretink visada, kai veiklos yra nepriklausomos, įjunk return_exceptions=True, kai daliniai gedimai yra priimtini, pasilik tęstinumą labai ilgiems apdorojimo darbams ir visada užtikrink, kad tavo šakojimasis remtųsi veiklų rezultatais, o ne nedeterministinėmis reikšmėmis.
Svarbiausi punktai
- Workflow gali inicijuoti kitus workflow per veiklą, kuri kviečia SDK
- Tęstinumo šablonas leidžia apdoroti neribotą elementų skaičių nuosekliomis grupėmis
asyncio.gatherleidžia vykdyti veiklas lygiagrečiai, sumažinant bendrą laiką- Sudėtingas sąlyginis šakojimasis yra palaikomas, jei jis priklauso nuo veiklų rezultatų
- Išskaidymo / sujungimo (fan-out / fan-in) šablonas paskirsto darbą ir tada sujungia rezultatus