Haladó minták
Ezen az oldalon
Frissítve: 2026. november 3.: Az al-munkafolyamat korábban az
execution.outputértéket adta vissza, amely hiányzik amistralaiSDK 3.7.0 verziójából. Az eredményt most aresultmezőből olvassuk ki, await_for_result=Trueparaméter használatával várva a befejezésre.
Túl az lineáris munkafolyamatokon
Eddig olyan munkafolyamatokat vizsgáltunk, amelyek tevékenységeket hajtanak végre szekvenciálisan. A gyakorlatban a valós esetek ennél összetettebb mintákat igényelnek: munkafolyamatok láncolása, tevékenységek párhuzamos futtatása vagy komplex feltételes döntések meghozatala. Ez a négy minta – a láncolás, a folytatás, a párhuzamosítás és a szétosztás/összegzés (fan-out/fan-in) – lefedi szinte minden olyan architektúrát, amelyet valaha is fel kell építened.
Munkafolyamatok láncolása
Egy munkafolyamat képes másik munkafolyamatot elindítani. Ez a képesség két különböző célt szolgál: az összetett logika újrafelhasználható al-munkafolyamatokra bontását, valamint az egyes végrehajtásokra vonatkozó 51 200 eseményes korlát megkerülését, mivel minden gyermek munkafolyamat saját kerettel rendelkezik. A mechanizmus egy tevékenységre támaszkodik, mivel ez az egyetlen hely, ahol az SDK jogosult hálózati hívást kezdeményezni.
import mistralai.workflows as workflows
from mistralai.client import Mistral
@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
"""Elindít egy gyermek munkafolyamatot, és megvárja az eredményét."""
client = Mistral()
execution = await client.workflows.execute_workflow_async(
workflow_identifier=workflow_name,
input=input_data,
wait_for_result=True, # megvárja a gyermek munkafolyamat eredményét
)
return execution.result
@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
# 1. lépés: Adatgyűjtés (dedikált al-munkafolyamat)
data = await launch_sub_workflow(
"data_collection",
{"sources": params["sources"]}
)
# 2. lépés: Elemzés (dedikált al-munkafolyamat)
analysis = await launch_sub_workflow(
"content_analysis",
{"data": data}
)
# 3. lépés: Jelentéskészítés (dedikált al-munkafolyamat)
report = await launch_sub_workflow(
"report_generation",
{"analysis": analysis, "format": params["format"]}
)
return report
Az előny túlmutat az egyszerű olvashatóságon: a data_collection önálló munkafolyamattá válik, amely izoláltan tesztelhető és más folyamatok által is újrafelhasználható, saját időtúllépési és újrapróbálkozási szabályokkal.
Ugyanez a mechanizmus, ha egy olyan munkafolyamatra alkalmazzuk, amely önmagát hívja meg, létrehozza a folytatási mintát. Ahelyett, hogy százezer elemet dolgoznánk fel egyetlen végrehajtásban – amit az eseménykorlát tiltana –, a munkafolyamat feldolgoz egy köteget, majd a maradékot egy új példányra bízza.
@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
# A jelenlegi köteg lekérése
batch = await retrieve_batch(offset, batch_size)
if not batch["items"]:
# Minden köteg feldolgozva
return {"status": "completed", "total_processed": offset}
# A jelenlegi köteg feldolgozása
await process_batch(batch["items"])
# A következő köteg elindítása egy új munkafolyamaton keresztül
next_batch = await launch_sub_workflow(
"batch_processing",
{"offset": offset + batch_size}
)
return next_batch
Minden új végrehajtás tiszta naplóval indul. A feldolgozható elemek száma így korlátlanná válik, a leállási feltétel pedig egyszerűen egy üres köteg.
Párhuzamosítás az asyncio.gather segítségével
Amikor több tevékenység független egymástól, nincs ok sorban futtatni őket. Az asyncio.gather egyszerre nyújtja be őket a platformnak, így a teljes időtartam inkább a leglassabb tevékenység idejéhez közelít, semmint az összes idejének összegéhez.
import asyncio
import mistralai.workflows as workflows
@workflows.activity()
async def analyze_source(url: str) -> dict:
"""Elemzi az adatforrást."""
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:
# Minden elemzés párhuzamos elindítása
results = await asyncio.gather(
*[analyze_source(url) for url in urls]
)
return {
"source_count": len(results),
"results": list(results)
}
Van azonban egy fontos figyelmeztetés: alapértelmezés szerint a gather továbbítja az első encountered kivételt, és megszakítja az egész csoportot. Ha negyven külső forrást elemzel, már egyetlen offline forrás is okozhatja, hogy elveszítsd a másik harminckilencet. A return_exceptions=True paraméter megváltoztatja ezt a viselkedést: a hibák rendes értékként térnek vissza, így rád marad a rendezésük.
@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# A return_exceptions=True megakadályozza, hogy egy hiba blokkolja a többit
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)
}
Ez a munkafolyamat egy részleges eredményt ad vissza egy sikerességi rátával együtt, lehetővé téve a downstream folyamatok számára, hogy eldöntsék: megfelelő-e a minőség, vagy szükség van-e újrapróbálkozásra.
Döntéshozatal a munkafolyamatban
A komplex elágazások nemcsak megengedettek, hanem gyakran a munkafolyamatok használatának fő céljai, feltéve, hogy a feltételek tevékenységek eredményeiből származnak. A tartalom-moderáció esete jól illusztrálja ezt a lépcsőzetes logikát: automatikus döntés, ha a modell nagyon magabiztos; második vélemény, ha a magabiztosság közepes; és emberi eskaláció véleményeltérés vagy alacsony magabiztosság esetén.
@workflows.workflow.define(name="content_moderation")
class ContentModeration:
@workflows.workflow.entrypoint
async def run(self, content: dict) -> dict:
# 1. lépés: Automatikus elemzés
analysis = await auto_analyze_content(content["text"])
if analysis["confidence_score"] > 0.95:
# Magas magabiztosság: automatikus döntés
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:
# Közepes magabiztosság: második elemzés egy másik modellel
second_analysis = await analyze_content_model_b(content["text"])
if analysis["category"] == second_analysis["category"]:
# Mindkét modell egyetért
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:
# Véleményeltérés: emberi eskaláció
await escalate_moderation(content["id"], analysis, second_analysis)
return {"decision": "pending", "method": "human_escalation"}
else:
# Alacsony magabiztosság: közvetlen eskaláció
await escalate_moderation(content["id"], analysis, None)
return {"decision": "pending", "method": "human_escalation"}
Figyeld meg a method mezőt, amely minden kilépési pontnál visszatér: ez lehetővé teszi, hogy utólag mérd, a tartalom mekkora hányadát dolgozták fel emberi beavatkozás nélkül, és ennek megfelelően állítsd be a küszöbértékeket.
Szétosztás / Összegzés (Fan-out / Fan-in)
Az utolsó minta kombinálja az előzőeket: a munka párhuzamos szétosztása, majd az eredmények egyetlen ponton történő összegzése. Itt egy dokumentumot egyszerre fordítanak le három nyelvre, minden fordítást párhuzamosan elemeznek, majd minden konvergál egy összefoglalóba.
@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
@workflows.workflow.entrypoint
async def run(self, document: dict) -> dict:
# Fan-out: párhuzamos fordítás 3 nyelvre
translations = await asyncio.gather(
translate(document["text"], "en"),
translate(document["text"], "de"),
translate(document["text"], "es")
)
# Fan-out: minden fordítás párhuzamos elemzése
analyses = await asyncio.gather(
*[analyze_sentiment(trad["translated_text"]) for trad in translations]
)
# Fan-in: eredmények összegzése
summary = await aggregate_analyses(list(analyses))
return summary
A két párhuzamosítási hullám egymást követi, mivel a második az első eredményeitől függ. Szigorú szekvenciában ez a munkafolyamat hét láncolt hívást igényelne; itt azonban csak három orchestrációs lépésbe kerül.
Összefoglalva: bontsd az összetett munkafolyamatokat újrafelhasználható al-munkafolyamatokra, párhuzamosítsd a tevékenységeket, amikor azok függetlenek, engedélyezd a return_exceptions=True opciót, ha a részleges hibák tolerálhatók, tartsd tartalékban a folytatási mintát nagyon hosszú feldolgozási feladatokhoz, és mindig győződj meg róla, hogy az elágazásaid tevékenységek eredményein alapulnak, nem pedig nem determinisztikus értékeken.
Főbb megállapítások
- Egy munkafolyamat más munkafolyamatokat is elindíthat egy olyan tevékenységen keresztül, amely meghívja az SDK-t
- A folytatási minta lehetővé teszi korlátlan számú elem feldolgozását egymást követő kötegekben
- Az
asyncio.gatherlehetővé teszi a tevékenységek párhuzamos futtatását a teljes idő csökkentése érdekében - A komplex feltételes elágazások támogatottak, amennyiben azok tevékenységek eredményeitől függenek
- A szétosztás / összegzés (fan-out / fan-in) minta szétosztja a munkát, majd összegzi az eredményeket