Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Avancerede mønstre

Lektion 11 af 14 Opdateret 3. november 2026 Avanceret
På denne side
  1. Ud over lineære workflows
  2. Kædning af workflows
  3. Parallelisering med asyncio.gather
  4. Træffe beslutninger i workflowet
  5. Fan-out / Fan-in
  6. Vigtige pointer

Opdateret 3. november 2026: Under-workflowet returnerede tidligere execution.output, hvilket mangler i mistralai SDK 3.7.0. Resultatet læses nu fra result ved hjælp af wait_for_result=True for at vente på fuldførelse.

Ud over lineære workflows

Indtil videre har vi kigget på workflows, der udfører aktiviteter sekventielt. I praksis kræver virkelige brugstilfælde mere sofistikerede mønstre: kædning af workflows, kørsel af aktiviteter parallelt eller træffelse af komplekse betingede beslutninger. Disse fire mønstre – kædning, fortsættelse, parallelisme og fan-out/fan-in – dækker næsten enhver arkitektur, du får brug for at bygge.

Kædning af workflows

Et workflow kan udløse et andet workflow. Denne funktion tjener to forskellige formål: at opdele kompleks logik i genanvendelige under-workflows og at omgå grænsen på 51.200 begivenheder pr. eksekvering, da hvert under-workflow får sit eget budget. Mekanismen afhænger af en aktivitet, som er det eneste sted, hvor SDK’et legitimt kan foretage et netværkskald.

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

@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
    """Starter et under-workflow og venter på dets resultat."""
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier=workflow_name,
        input=input_data,
        wait_for_result=True,  # vent på resultatet fra under-workflowet
    )
    return execution.result

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

        # Trin 2: Analyse (dedikeret under-workflow)
        analysis = await launch_sub_workflow(
            "content_analysis",
            {"data": data}
        )

        # Trin 3: Rapportgenerering (dedikeret under-workflow)
        report = await launch_sub_workflow(
            "report_generation",
            {"analysis": analysis, "format": params["format"]}
        )

        return report

Fordelen går ud over simpel læsbarhed: data_collection bliver et selvstændigt workflow, der kan testes isoleret og genbruges af andre pipelines med sine egne tidsudløb og genforsøgspolitikker.

Den samme mekanisme, anvendt på et workflow, der kalder sig selv, skaber fortsættelsesmønsteret. I stedet for at behandle hundrede tusind elementer i en enkelt eksekvering – hvilket begivenhedsgrænsen forbyder – behandler workflowet en batch og delegerer resten til en ny instans.

@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

        # Hent den aktuelle batch
        batch = await retrieve_batch(offset, batch_size)

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

        # Behandl den aktuelle batch
        await process_batch(batch["items"])

        # Start næste batch via et nyt workflow
        next_batch = await launch_sub_workflow(
            "batch_processing",
            {"offset": offset + batch_size}
        )

        return next_batch

Hver ny eksekvering starter med en ren journal. Antallet af elementer, der kan behandles, bliver ubegrænset, hvor stopbetingelsen simpelthen er en tom batch.

Parallelisering med asyncio.gather

Når flere aktiviteter er uafhængige af hinanden, er der ingen grund til at køre dem sekventielt. asyncio.gather sender dem til platformen samtidigt, og den samlede tid nærmer sig den langsomste aktivitets varighed snarere end summen af dem alle.

import asyncio
import mistralai.workflows as workflows

@workflows.activity()
async def analyze_source(url: str) -> dict:
    """Analyserer en datakilde."""
    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 analyser parallelt
        results = await asyncio.gather(
            *[analyze_source(url) for url in urls]
        )

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

Der gælder dog en vigtig detalje: Som standard propagerer gather den første undtagelse, der opstår, og afbryder hele sættet. Hvis du analyserer fyrre eksterne kilder, vil blot én, der er offline, få dig til at miste de andre niogtredive. Parameteren return_exceptions=True ændrer denne adfærd: fejl returneres som almindelige værdier, så du selv kan sortere i dem.

@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, urls: list) -> dict:
        # return_exceptions=True forhindrer, at én fejl blokerer de andre
        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)
        }

Dette workflow returnerer et delvist resultat ledsaget af en succesrate, hvilket giver efterfølgende processer mulighed for at beslutte, om kvaliteten er tilstrækkelig, eller om et genforsøg er nødvendigt.

Træffe beslutninger i workflowet

Kompleks forgrening er ikke kun tilladt, men ofte hovedpointen ved at bruge workflows, forudsat at betingelserne stammer fra aktivitetsresultater. Tilfældet med indholdsmoderation illustrerer denne kaskadelogik godt: automatisk beslutning, når modellen er meget sikker, en anden udtalelse, når sikkerheden er moderat, og eskalering til menneske i tilfælde af uenighed eller lav sikkerhed.

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

        if analysis["confidence_score"] > 0.95:
            # Høj sikkerhed: automatisk beslutning
            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:
            # Moderat sikkerhed: anden analyse med en anden model
            second_analysis = await analyze_content_model_b(content["text"])

            if analysis["category"] == second_analysis["category"]:
                # Begge modeller er enige
                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:
                # Uenighed: eskalering til menneske
                await escalate_moderation(content["id"], analysis, second_analysis)
                return {"decision": "pending", "method": "human_escalation"}

        else:
            # Lav sikkerhed: direkte eskalering
            await escalate_moderation(content["id"], analysis, None)
            return {"decision": "pending", "method": "human_escalation"}

Bemærk feltet method, der returneres ved hvert udgangspunkt: Det giver dig mulighed for retrospektivt at måle, hvilken andel af indholdet der blev behandlet uden menneskelig indgriben, og dermed justere tærskelværdierne derefter.

Fan-out / Fan-in

Det sidste mønster kombinerer de tidligere: Fordel arbejde parallelt, og saml derefter resultaterne på ét punkt. Her oversættes et dokument samtidigt til tre sprog, hver oversættelse analyseres parallelt, og alt konvergerer til et sammendrag.

@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, document: dict) -> dict:
        # Fan-out: oversæt parallelt til 3 sprog
        translations = await asyncio.gather(
            translate(document["text"], "en"),
            translate(document["text"], "de"),
            translate(document["text"], "es")
        )

        # Fan-out: analyser hver oversættelse parallelt
        analyses = await asyncio.gather(
            *[analyze_sentiment(trad["translated_text"]) for trad in translations]
        )

        # Fan-in: saml resultaterne
        summary = await aggregate_analyses(list(analyses))

        return summary

De to bølger af parallelisme er successive, fordi den anden afhænger af resultaterne fra den første. I streng sekvens ville dette workflow kræve syv kædede kald; her koster det kun tre orkestreringstrin.

Kort sagt: Opdel komplekse workflows i genanvendelige under-workflows, parallelisér, når aktiviteter er uafhængige, aktiver return_exceptions=True, når delvise fejl er acceptable, hold fortsættelse i reserve til meget lange behandlingsjob, og sørg altid for, at din forgrening afhænger af aktivitetsresultater snarere end ikke-deterministiske værdier.

Vigtige pointer

  • Et workflow kan udløse andre workflows via en aktivitet, der kalder SDK’et
  • Mønsteret fortsættelse gør det muligt at behandle et ubegrænset antal elementer i successive batches
  • asyncio.gather lader dig køre aktiviteter parallelt for at reducere den samlede tid
  • Kompleks betinget forgrening understøttes, så længe den afhænger af aktivitetsresultater
  • Mønsteret fan-out / fan-in fordeler arbejde og samler derefter resultaterne