Modele avansate
Pe această pagină
Actualizat la 3 noiembrie 2026: Sub-fluxul de lucru returna anterior
execution.output, care lipsește din SDK-ulmistralaiversiunea 3.7.0. Rezultatul se citește acum dinresult, folosindwait_for_result=Truepentru a aștepta finalizarea.
Dincolo de fluxurile de lucru liniare
Până acum, am examinat fluxuri de lucru care execută activități secvențial. În practică, cazurile de utilizare din lumea reală necesită modele mai sofisticate: înlănțuirea fluxurilor de lucru, rularea activităților în paralel sau luarea unor decizii condiționale complexe. Aceste patru modele—înlănțuirea, continuarea, paralelismul și fan-out/fan-in—acoperă aproape orice arhitectură pe care veți avea nevoie să o construiți.
Înlănțuirea fluxurilor de lucru
Un flux de lucru poate declanșa un alt flux de lucru. Această capacitate servește două obiective distincte: descompunerea logicii complexe în sub-fluxuri de lucru reutilizabile și ocolirea limitei de 51.200 de evenimente per execuție, deoarece fiecare flux de lucru copil primește propriul buget. Mecanismul se bazează pe o activitate, singurul loc în care SDK-ul poate face legitim o apelare de rețea.
import mistralai.workflows as workflows
from mistralai.client import Mistral
@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
"""Lansează un flux de lucru copil și așteaptă rezultatul acestuia."""
client = Mistral()
execution = await client.workflows.execute_workflow_async(
workflow_identifier=workflow_name,
input=input_data,
wait_for_result=True, # așteaptă rezultatul fluxului de lucru copil
)
return execution.result
@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
# Pasul 1: Colectarea datelor (sub-flux de lucru dedicat)
data = await launch_sub_workflow(
"data_collection",
{"sources": params["sources"]}
)
# Pasul 2: Analiza (sub-flux de lucru dedicat)
analysis = await launch_sub_workflow(
"content_analysis",
{"data": data}
)
# Pasul 3: Generarea raportului (sub-flux de lucru dedicat)
report = await launch_sub_workflow(
"report_generation",
{"analysis": analysis, "format": params["format"]}
)
return report
Beneficiul depășește simpla lizibilitate: data_collection devine un flux de lucru de sine stătător, testabil izolat și reutilizabil de alte pipeline-uri, cu propriile sale timeout-uri și politici de reîncercare.
Același mecanism, aplicat unui flux de lucru care se apelează pe sine, creează modelul de continuare. În loc să proceseze o sută de mii de elemente într-o singură execuție—ceea ce limita de evenimente interzice—fluxul de lucru procesează un lot și deleagă restul unei noi instanțe.
@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
# Preia lotul curent
batch = await retrieve_batch(offset, batch_size)
if not batch["items"]:
# Toate loturile au fost procesate
return {"status": "completed", "total_processed": offset}
# Procesează lotul curent
await process_batch(batch["items"])
# Lansează lotul următor printr-un nou flux de lucru
next_batch = await launch_sub_workflow(
"batch_processing",
{"offset": offset + batch_size}
)
return next_batch
Fiecare nouă execuție începe cu un jurnal curat. Numărul de elemente procesabile devine nelimitat, condiția de oprire fiind pur și simplu un lot gol.
Paralelizarea cu asyncio.gather
Când mai multe activități sunt independente unele de altele, nu există niciun motiv să le rulați în secvență. asyncio.gather le trimite platformei simultan, iar timpul total se apropie de cel al celei mai lente activități, mai degrabă decât de suma tuturor.
import asyncio
import mistralai.workflows as workflows
@workflows.activity()
async def analyze_source(url: str) -> dict:
"""Analizează o sursă de date."""
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:
# Lansează toate analizele în paralel
results = await asyncio.gather(
*[analyze_source(url) for url in urls]
)
return {
"source_count": len(results),
"results": list(results)
}
Există totuși o nuanță: implicit, gather propagă prima excepție întâlnită și întrerupe întregul set. Dacă analizați patruzeci de surse externe, faptul că doar una este offline vă face să le pierdeți pe celelalte treizeci și nouă. Parametrul return_exceptions=True modifică acest comportament: erorile sunt returnate ca valori obișnuite, lăsându-vă să le gestionați.
@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# return_exceptions=True previne ca o eroare să blocheze celelalte
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)
}
Acest flux de lucru returnează un rezultat parțial însoțit de o rată de succes, permițând proceselor din aval să decidă dacă calitatea este suficientă sau dacă este necesară o reîncercare.
Luarea deciziilor în fluxul de lucru
Ramificarea complexă nu este doar permisă, ci adesea reprezintă scopul principal al utilizării fluxurilor de lucru, cu condiția ca condițiile să derive din rezultatele activităților. Cazul moderării conținutului ilustrează bine această logică în cascadă: decizie automată când modelul este foarte sigur, o a doua opinie când încrederea este moderată și escaladare umană în caz de dezacord sau încredere scăzută.
@workflows.workflow.define(name="content_moderation")
class ContentModeration:
@workflows.workflow.entrypoint
async def run(self, content: dict) -> dict:
# Pasul 1: Analiza automată
analysis = await auto_analyze_content(content["text"])
if analysis["confidence_score"] > 0.95:
# Încredere ridicată: decizie automată
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:
# Încredere moderată: a doua analiză cu un model diferit
second_analysis = await analyze_content_model_b(content["text"])
if analysis["category"] == second_analysis["category"]:
# Ambele modele sunt de acord
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:
# Dezacord: escaladare umană
await escalate_moderation(content["id"], analysis, second_analysis)
return {"decision": "pending", "method": "human_escalation"}
else:
# Încredere scăzută: escaladare directă
await escalate_moderation(content["id"], analysis, None)
return {"decision": "pending", "method": "human_escalation"}
Observați câmpul method returnat la fiecare punct de ieșire: acesta vă permite să măsurați retrospectiv ce proporție din conținut a fost procesată fără intervenție umană și, astfel, să ajustați pragurile în consecință.
Fan-out / Fan-in
Ultimul model le combină pe cele anterioare: distribuirea lucrului în paralel, apoi agregarea rezultatelor într-un singur punct. Aici, un document este tradus simultan în trei limbi, fiecare traducere este analizată în paralel, iar totul converge într-un rezumat.
@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
@workflows.workflow.entrypoint
async def run(self, document: dict) -> dict:
# Fan-out: traducere în paralel în 3 limbi
translations = await asyncio.gather(
translate(document["text"], "en"),
translate(document["text"], "de"),
translate(document["text"], "es")
)
# Fan-out: analizarea fiecărei traduceri în paralel
analyses = await asyncio.gather(
*[analyze_sentiment(trad["translated_text"]) for trad in translations]
)
# Fan-in: agregarea rezultatelor
summary = await aggregate_analyses(list(analyses))
return summary
Cele două valuri de paralelism sunt succesive deoarece al doilea depinde de rezultatele primului. În secvență strictă, acest flux de lucru ar necesita șapte apeluri înlănțuite; aici, costă doar trei pași de orchestrare.
În concluzie, descompuneți fluxurile de lucru complexe în sub-fluxuri reutilizabile, paralelizați ori de câte ori activitățile sunt independente, activați return_exceptions=True când eșecurile parțiale sunt tolerabile, păstrați continuarea ca rezervă pentru joburi de procesare foarte lungi și asigurați-vă întotdeauna că ramificarea se bazează pe rezultatele activităților, nu pe valori nedeterministe.
Puncte cheie
- Un flux de lucru poate declanșa alte fluxuri de lucru printr-o activitate care apelează SDK-ul
- Modelul de continuare permite procesarea unui număr nelimitat de elemente în loturi succesive
asyncio.gathervă permite să rulați activități în paralel pentru a reduce timpul total- Ramificarea condițională complexă este suportată atâta timp cât depinde de rezultatele activităților
- Modelul fan-out / fan-in distribuie lucrul și apoi agregă rezultatele