Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Avancerade mönster

Lektion 11 av 14 Uppdaterad 3 november 2026 Avancerad
På denna sida
  1. Utöver linjära arbetsflöden
  2. Kedjekoppling av arbetsflöden
  3. Parallellisering med asyncio.gather
  4. Att fatta beslut i arbetsflödet
  5. Fan-out / Fan-in
  6. Viktiga punkter

Uppdaterad 3 november 2026: Underflödet returnerade tidigare execution.output, vilket saknas i mistralai SDK 3.7.0. Resultatet läses nu från result, med hjälp av wait_for_result=True för att vänta på slutförande.

Utöver linjära arbetsflöden

Hittills har vi tittat på arbetsflöden som kör aktiviteter sekventiellt. I praktiken kräver verkliga användningsfall mer sofistikerade mönster: kedjekoppling av arbetsflöden, parallell körning av aktiviteter eller komplexa villkorliga beslut. Dessa fyra mönster – kedjekoppling, fortsättning, parallellism och fan-out/fan-in – täcker nästan alla arkitekturer du behöver bygga.

Kedjekoppling av arbetsflöden

Ett arbetsflöde kan trigga ett annat arbetsflöde. Denna funktionality tjänar två distinkta mål: att bryta ner komplex logik i återanvändbara underflöden och att kringgå gränsen på 51 200 händelser per exekvering, eftersom varje barnarbetsflöde får sin egen kvot. Mekanismen förlitar sig på en aktivitet, vilket är den enda plats där SDK:t legitimt kan göra ett nätverksanrop.

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

@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
    """Startar ett barnarbetsflöde och väntar på dess resultat."""
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier=workflow_name,
        input=input_data,
        wait_for_result=True,  # vänta på resultatet från barnarbetsflödet
    )
    return execution.result

@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        # Steg 1: Datainsamling (dedikerat underflöde)
        data = await launch_sub_workflow(
            "data_collection",
            {"sources": params["sources"]}
        )

        # Steg 2: Analys (dedikerat underflöde)
        analysis = await launch_sub_workflow(
            "content_analysis",
            {"data": data}
        )

        # Steg 3: Rapportgenerering (dedikerat underflöde)
        report = await launch_sub_workflow(
            "report_generation",
            {"analysis": analysis, "format": params["format"]}
        )

        return report

Fördelen går bortom enkel läsbarhet: data_collection blir ett fristående arbetsflöde, testbart i isolering och återanvändbart av andra pipelines, med egna tidsgränser och policyer för försök.

Samma mekanism, applicerad på ett arbetsflöde som anropar sig självt, skapar fortsättningsmönstret. Istället för att bearbeta hundratusentals objekt i en enda exekvering – vilket händelsegränsen förbjuder – bearbetar arbetsflödet en batch och delegerar resten till 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

        # Hämta aktuell batch
        batch = await retrieve_batch(offset, batch_size)

        if not batch["items"]:
            # Alla batchar bearbetade
            return {"status": "completed", "total_processed": offset}

        # Bearbeta aktuell batch
        await process_batch(batch["items"])

        # Starta nästa batch via ett nytt arbetsflöde
        next_batch = await launch_sub_workflow(
            "batch_processing",
            {"offset": offset + batch_size}
        )

        return next_batch

Varje ny exekvering startar med en ren journal. Antalet bearbetningsbara objekt blir obegränsat, där stoppvillkoret helt enkelt är en tom batch.

Parallellisering med asyncio.gather

När flera aktiviteter är oberoende av varandra finns det ingen anledning att köra dem i sekvens. asyncio.gather skickar dem till plattformen samtidigt, och den totala tiden närmar sig den för den långsammaste aktiviteten snarare än summan av alla.

import asyncio
import mistralai.workflows as workflows

@workflows.activity()
async def analyze_source(url: str) -> dict:
    """Analyserar en datakälla."""
    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:
        # Starta alla analyser parallellt
        results = await asyncio.gather(
            *[analyze_source(url) for url in urls]
        )

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

En varning gäller dock: som standard propagerar gather det första undantaget som uppstår och avbryter hela uppsättningen. Om du analyserar fyrtio externa källor leder bara en som är offline till att du förlorar de andra trettionio. Parametern return_exceptions=True ändrar detta beteende: fel returneras som vanliga värden, vilket lämnar åt dig att sortera ut dem.

@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, urls: list) -> dict:
        # return_exceptions=True förhindrar att ett fel blockerar de andra
        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)
        }

Detta arbetsflöde returnerar ett delresultat åtföljt av en framgångsfrekvens, vilket låter nedströmsprocesser avgöra om kvaliteten är tillräcklig eller om ett nytt försök behövs.

Att fatta beslut i arbetsflödet

Komplex förgrening är inte bara tillåten utan ofta huvudpoängen med att använda arbetsflöden, förutsatt att villkoren härleds från aktivitetsresultat. Fallet med innehållsmoderering illustrerar denna kaskadlogik väl: automatiskt beslut när modellen är mycket säker, en andra åsikt när säkerheten är måttlig och eskalering till människa vid oenighet eller låg säkerhet.

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

        if analysis["confidence_score"] > 0.95:
            # Hög säkerhet: automatiskt beslut
            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:
            # Måttlig säkerhet: andra analys med en annan modell
            second_analysis = await analyze_content_model_b(content["text"])

            if analysis["category"] == second_analysis["category"]:
                # Båda modellerna är överens
                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:
                # Oenighet: eskalering till människa
                await escalate_moderation(content["id"], analysis, second_analysis)
                return {"decision": "pending", "method": "human_escalation"}

        else:
            # Låg säkerhet: direkt eskalering
            await escalate_moderation(content["id"], analysis, None)
            return {"decision": "pending", "method": "human_escalation"}

Lägg märke till fältet method som returneras vid varje exit-punkt: det låter dig i efterhand mäta vilken andel av innehållet som bearbetades utan mänsklig inblandning, och därmed justera tröskelvärdena därefter.

Fan-out / Fan-in

Det sista mönstret kombinerar de tidigare: distribuera arbete parallellt och samla sedan resultaten på en enda punkt. Här översätts ett dokument samtidigt till tre språk, varje översättning analyseras parallellt och allt konvergerar till en sammanfattning.

@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, document: dict) -> dict:
        # Fan-out: översätt parallellt till 3 språk
        translations = await asyncio.gather(
            translate(document["text"], "en"),
            translate(document["text"], "de"),
            translate(document["text"], "es")
        )

        # Fan-out: analysera varje översättning parallellt
        analyses = await asyncio.gather(
            *[analyze_sentiment(trad["translated_text"]) for trad in translations]
        )

        # Fan-in: sammanställ resultat
        summary = await aggregate_analyses(list(analyses))

        return summary

De två vågorna av parallellism är successiva eftersom den andra beror på resultaten från den första. I strikt sekvens skulle detta arbetsflöde kräva sju kedjade anrop; här kostar det bara tre orkestreringssteg.

Sammanfattningsvis: bryt ner komplexa arbetsflöden i återanvändbara underflöden, parallellisera när aktiviteter är oberoende, aktivera return_exceptions=True när partiella fel är tolererbara, håll fortsättningsmönstret i reserv för mycket långa bearbetningsjobb och se alltid till att din förgrening förlitar sig på aktivitetsresultat snarare än icke-deterministiska värden.

Viktiga punkter

  • Ett arbetsflöde kan trigga andra arbetsflöden via en aktivitet som anropar SDK:t
  • Mönstret fortsättning möjliggör bearbetning av ett obegränsat antal objekt i successiva batchar
  • asyncio.gather låter dig köra aktiviteter parallellt för att minska den totala tiden
  • Komplex villkorlig förgrening stöds så länge den beror på aktivitetsresultat
  • Mönstret fan-out / fan-in distribuerar arbete och sammanställer sedan resultaten