Salt la conținutul principal
Română— Alege o limbă
Meniu

Modele avansate

Lecția 11 din 14 Actualizată 3 noiembrie 2026 Avansat
Pe această pagină
  1. Dincolo de fluxurile de lucru liniare
  2. Înlănțuirea fluxurilor de lucru
  3. Paralelizarea cu asyncio.gather
  4. Luarea deciziilor în fluxul de lucru
  5. Fan-out / Fan-in
  6. Puncte cheie

Actualizat la 3 noiembrie 2026: Sub-fluxul de lucru returna anterior execution.output, care lipsește din SDK-ul mistralai versiunea 3.7.0. Rezultatul se citește acum din result, folosind wait_for_result=True pentru 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.gather vă 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