Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Patronen geavanceerd

Les 11 van 14 Bijgewerkt op 3 november 2026 Gevorderd
Op deze pagina
  1. Voorbij lineaire workflows
  2. Workflows aan elkaar koppelen
  3. Paralleliseren met asyncio.gather
  4. Beslissingen nemen in de workflow
  5. Fan-out / Fan-in
  6. Belangrijkste punten

Bijgewerkt op 3 november 2026: De sub-workflow gaf eerder execution.output terug, wat ontbreekt in mistralai SDK 3.7.0. Het resultaat wordt nu uitgelezen uit result, waarbij wait_for_result=True wordt gebruikt om op voltooiing te wachten.

Voorbij lineaire workflows

Tot nu toe hebben we workflows bekeken die activiteiten sequentieel uitvoeren. In de praktijk vereisen use cases uit de echte wereld echter geavanceerdere patronen: workflows aan elkaar koppelen, activiteiten parallel uitvoeren of complexe conditionele beslissingen nemen. Deze vier patronen—kettingvorming, continuïteit, parallelisme en fan-out/fan-in—dekken bijna elke architectuur die u zult moeten bouwen.

Workflows aan elkaar koppelen

Een workflow kan een andere workflow activeren. Deze mogelijkheid dient twee verschillende doelen: complexe logica opsplitsen in herbruikbare sub-workflows en de limiet van 51.200 events per uitvoering omzeilen, aangezien elke child-workflow zijn eigen budget krijgt. Het mechanisme vertrouwt op een activiteit, de enige plek waar de SDK legitiem een netwerkaanroep kan doen.

import mistralai.workflows as workflows
from mistralai.client import Mistral

@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
    """Start een child-workflow en wacht op het resultaat."""
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier=workflow_name,
        input=input_data,
        wait_for_result=True,  # wacht op het resultaat van de child-workflow
    )
    return execution.result

@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        # Stap 1: Dataverzameling (toegewijde sub-workflow)
        data = await launch_sub_workflow(
            "data_collection",
            {"sources": params["sources"]}
        )

        # Stap 2: Analyse (toegewijde sub-workflow)
        analysis = await launch_sub_workflow(
            "content_analysis",
            {"data": data}
        )

        # Stap 3: Rapportgeneratie (toegewijde sub-workflow)
        report = await launch_sub_workflow(
            "report_generation",
            {"analysis": analysis, "format": params["format"]}
        )

        return report

Het voordeel gaat verder dan eenvoudige leesbaarheid: data_collection wordt een zelfstandige workflow, geïsoleerd testbaar en herbruikbaar door andere pipelines, met eigen time-outs en retry-beleid.

Hetzelfde mechanisme, toegepast op een workflow die zichzelf aanroept, creëert het continuïteitspatroon. In plaats van honderdduizend items in één uitvoering te verwerken—wat de event-limiet verbiedt—verwerkt de workflow een batch en delegeert de rest aan een nieuwe instantie.

@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

        # Haal de huidige batch op
        batch = await retrieve_batch(offset, batch_size)

        if not batch["items"]:
            # Alle batches verwerkt
            return {"status": "completed", "total_processed": offset}

        # Verwerk de huidige batch
        await process_batch(batch["items"])

        # Start de volgende batch via een nieuwe workflow
        next_batch = await launch_sub_workflow(
            "batch_processing",
            {"offset": offset + batch_size}
        )

        return next_batch

Elke nieuwe uitvoering start met een schoon journaal. Het aantal verwerkbare items wordt onbeperkt, waarbij de stopvoorwaarde simpelweg een lege batch is.

Paralleliseren met asyncio.gather

Wanneer meerdere activiteiten onafhankelijk van elkaar zijn, is er geen reden om ze sequentieel uit te voeren. asyncio.gather dient ze gelijktijdig in bij het platform, en de totale tijd benadert die van de traagste activiteit in plaats van de som van allemaal.

import asyncio
import mistralai.workflows as workflows

@workflows.activity()
async def analyze_source(url: str) -> dict:
    """Analyseert een databron."""
    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:
        # Start alle analyses parallel
        results = await asyncio.gather(
            *[analyze_source(url) for url in urls]
        )

        return {
            "source_count": len(results),
            "results": list(results)
        }

Er geldt echter één aandachtspunt: standaard propageert gather de eerste encountered uitzondering en breekt het de hele set af. Als u veertig externe bronnen analyseert, zorgt slechts één offline bron ervoor dat u de andere negenendertig kwijtraakt. De parameter return_exceptions=True verandert dit gedrag: fouten worden teruggegeven als gewone waarden, zodat u ze zelf kunt sorteren.

@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, urls: list) -> dict:
        # return_exceptions=True voorkomt dat één fout de anderen blokkeert
        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)
        }

Deze workflow geeft een gedeeltelijk resultaat terug, vergezeld van een slagingspercentage, zodat downstream-processen kunnen beslissen of de kwaliteit voldoende is of dat een retry nodig is.

Beslissingen nemen in de workflow

Complexe vertakkingen zijn niet alleen toegestaan, maar vaak het hoofddoel van het gebruik van workflows, mits de voorwaarden voortvloeien uit activiteitsresultaten. De case voor contentmoderatie illustreert deze cascaderende logica goed: automatische beslissing wanneer het model zeer zeker is, een second opinion bij matige zekerheid, en escalatie naar een mens bij meningsverschil of lage zekerheid.

@workflows.workflow.define(name="content_moderation")
class ContentModeration:
    @workflows.workflow.entrypoint
    async def run(self, content: dict) -> dict:
        # Stap 1: Automatische analyse
        analysis = await auto_analyze_content(content["text"])

        if analysis["confidence_score"] > 0.95:
            # Hoge zekerheid: automatische beslissing
            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:
            # Matige zekerheid: tweede analyse met een ander model
            second_analysis = await analyze_content_model_b(content["text"])

            if analysis["category"] == second_analysis["category"]:
                # Beide modellen zijn het eens
                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:
                # Meningsverschil: escalatie naar mens
                await escalate_moderation(content["id"], analysis, second_analysis)
                return {"decision": "pending", "method": "human_escalation"}

        else:
            # Lage zekerheid: directe escalatie
            await escalate_moderation(content["id"], analysis, None)
            return {"decision": "pending", "method": "human_escalation"}

Merk op dat het veld method op elk exitpunt wordt teruggegeven: hiermee kunt u achteraf meten welk percentage van de content zonder menselijke tussenkomst is verwerkt, en zo de drempelwaarden dienovereenkomstig aanpassen.

Fan-out / Fan-in

Het laatste patroon combineert de vorige: werk distribueren in parallel, en vervolgens de resultaten op één punt aggregeren. Hier wordt een document gelijktijdig naar drie talen vertaald, wordt elke vertaling parallel geanalyseerd, en komt alles samen in een samenvatting.

@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, document: dict) -> dict:
        # Fan-out: parallel vertalen naar 3 talen
        translations = await asyncio.gather(
            translate(document["text"], "en"),
            translate(document["text"], "de"),
            translate(document["text"], "es")
        )

        # Fan-out: elke vertaling parallel analyseren
        analyses = await asyncio.gather(
            *[analyze_sentiment(trad["translated_text"]) for trad in translations]
        )

        # Fan-in: resultaten aggregeren
        summary = await aggregate_analyses(list(analyses))

        return summary

De twee golven van parallelisme zijn opeenvolgend omdat de tweede afhangt van de resultaten van de eerste. In strikte sequentie zou deze workflow zeven gekoppelde aanroepen vereisen; hier kost het slechts drie orchestratiestappen.

Samenvattend: breek complexe workflows op in herbruikbare sub-workflows, parallelleer waar activiteiten onafhankelijk zijn, schakel return_exceptions=True in wanneer gedeeltelijke fouten aanvaardbaar zijn, houd continuïteit achter de hand voor zeer lange verwerkingstaken, en zorg er altijd voor dat uw vertakkingen berusten op activiteitsresultaten in plaats van niet-deterministische waarden.

Belangrijkste punten

  • Een workflow kan andere workflows activeren via een activiteit die de SDK aanroept
  • Het continuïteitspatroon maakt het mogelijk een onbeperkt aantal items in opeenvolgende batches te verwerken
  • Met asyncio.gather kunt u activiteiten parallel uitvoeren om de totale tijd te verkorten
  • Complexe conditionele vertakkingen worden ondersteund zolang deze afhangen van activiteitsresultaten
  • Het fan-out / fan-in-patroon distribueert werk en aggregeert vervolgens de resultaten