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

Skapa ett arbetsflöde

Lektion 5 av 14 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Arbetsflödets roll
  2. Arbetsflödets struktur
  3. Komplett exempel: bearbetningspipeline
  4. Arbetsflödets hållbarhet
  5. Arbetsflöde med villkorlig förgrening
  6. Indata med Pydantic
  7. Bästa praxis
  8. Viktiga punkter

Arbetsflödets roll

Arbetsflödet är ditt programs orkestreringslager. Det definierar vad som måste hända, i vilken ordning och under vilka villkor – utan att själva utföra arbetet. Konkret koordinerar det aktiviteter, väntar på externa händelser, hanterar timers och villkorliga grenar, men det rör aldrig nätverket eller disken.

Du kan sammanfatta detta i en fras att ha i åtanke varje gång du granskar kod: aktiviteter gör jobbet, arbetsflödet styr. Om du ser httpx eller open() inuti en arbetsflödesklass måste något flyttas.

Arbetsflödets struktur

Ett arbetsflöde är en Python-klass dekorerad med @workflows.workflow.define(), som innehåller en startmetod dekorerad med @workflows.workflow.entrypoint:

import mistralai.workflows as workflows

@workflows.workflow.define(name="mon_premier_workflow")
class MonPremierWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, nom: str) -> dict:
        """Workflow entry point."""
        resultat = await saluer(nom)
        return resultat

Dekoratorn @workflows.workflow.define(name="...") registrerar klassen som ett arbetsflöde. Det name den får är den unika identifierare du använder för att trigga en körning – det är denna sträng, inte Python-klassnamnet, som anroparen ser. Dekoratorn @workflows.workflow.entrypoint markerar metoden som anropas vid start. Den första parametern, self, förblir klassinstansen, precis som i alla Python-objekt, och varje aktivitetsanrop använder await.

Komplett exempel: bearbetningspipeline

Här är ett realistiskt arbetsflöde som orkestrerar flera aktiviteter för att bearbeta ett dokument. Lägg märke till arbetsfördelningen: de tre funktionerna högst upp innehåller all kod som interagerar med omvärlden, medan klassen längst ner bara kedjar await-anrop och sätter ihop ett resultat.

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

# --- Activities ---

@workflows.activity()
async def extraire_texte(url_document: str) -> dict:
    """Download and extract text from a document."""
    async with httpx.AsyncClient() as client:
        response = await client.get(url_document)
        texte = response.text
    return {"texte": texte, "longueur": len(texte)}

@workflows.activity()
async def analyser_avec_mistral(texte: str) -> dict:
    """Analyze text with Mistral to extract key points."""
    client = Mistral()
    response = await client.chat.complete_async(
        model="mistral-large-latest",
        messages=[
            {"role": "system", "content": "Extract the 5 key points from this text."},
            {"role": "user", "content": texte}
        ]
    )
    return {"analyse": response.choices[0].message.content}

@workflows.activity()
async def sauvegarder_resultat(analyse: dict) -> dict:
    """Save the analysis result."""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            "https://api.example.com/rapports",
            json=analyse
        )
        return {"id_rapport": response.json()["id"]}

# --- Workflow ---

@workflows.workflow.define(name="pipeline_analyse_document")
class PipelineAnalyseDocument:
    @workflows.workflow.entrypoint
    async def run(self, url_document: str) -> dict:
        """Orchestrate extraction, analysis, and saving."""
        # Step 1: Extract text
        extraction = await extraire_texte(url_document)

        # Step 2: Analyze with Mistral
        analyse = await analyser_avec_mistral(extraction["texte"])

        # Step 3: Save
        sauvegarde = await sauvegarder_resultat(analyse)

        return {
            "url_source": url_document,
            "longueur_texte": extraction["longueur"],
            "id_rapport": sauvegarde["id_rapport"]
        }

Varje await i arbetsflödet utgör en persistenspunkt. Det är värt att mentalt verifiera detta med exemplet ovan: om processen misslyckas mellan steg 2 och steg 3 kommer dokumentet inte att laddas ner igen och modellen kommer inte att anropas på nytt – inga extra token-kostnader alltså. Arbetsflödet återupptas direkt vid sparsteget.

Arbetsflödets hållbarhet

Arbetsflöden överlever omstarter, infrastrukturfel och tillfälliga fel eftersom plattformen registrerar varje händelse och återskapar arbetsflödets tillstånd under replay. Denna återskapning är endast tillförlitlig under ett villkor, nämnt tidigare: arbetsflödeskoden måste alltid producera samma sekvens av operationer för samma indata. Detta är determinism-kravet. Vi går igenom detaljerna i lektion 8.

Arbetsflöde med villkorlig förgrening

Ett arbetsflöde är inte begränsat till en linjär sekvens. Det kan innehålla villkorlig logik, som i detta exempel på orderhantering där vägen beror på lagerstatus:

@workflows.workflow.define(name="traitement_commande")
class OrderProcessing:
    @workflows.workflow.entrypoint
    async def run(self, order: dict) -> dict:
        # Check stock
        stock = await check_stock(order["produit_id"])

        if stock["disponible"]:
            # Standard path
            payment = await process_payment(order["montant"])
            shipment = await prepare_shipment(order)
            await send_confirmation(order["email"], shipment)
            return {"status": "confirmée", "tracking": shipment["tracking"]}
        else:
            # Alternative path
            await notify_stockout(order["email"], order["produit_id"])
            return {"status": "rupture_stock"}

if/else-grenar stöds fullt ut. Det enda kravet gäller materialet som används för beslutet: grenens utfall måste bero på returvärdet från en aktivitet – ett värde som loggats och spelas upp identiskt – inte på ett direkt anrop till en extern tjänst från arbetsflödet. Här frågar verifier_stock lagret inom en aktivitet, och if-satsen läser bara en ordbok som redan har persistenslagrats.

Indata med Pydantic

Ett arbetsflöde som tar sex positionsparametrar blir snabbt oläsligt. För strukturerade indata använder du Pydantic-modeller, vilket också ger typvalidering vid start av körningen:

from pydantic import BaseModel

class ReportParams(BaseModel):
    report_type: str
    include_details: bool = False
    start_date: str
    end_date: str

@workflows.workflow.define(name="generation_rapport")
class ReportGeneration:
    @workflows.workflow.entrypoint
    async def run(self, params: ReportParams) -> dict:
        data = await collect_data(params.report_type, params.start_date, params.end_date)
        
        if params.include_details:
            data = await enrich_data(data)
        
        report = await generate_pdf_report(data)
        return {"url_rapport": report["url"]}

En viktig punkt att tänka på när du triggar detta arbetsflöde: när du använder en BaseModel blir fälten nycklar på toppnivå i JSON-indatat som skickas till arbetsflödet. Du skickar {"type_rapport": ..., "date_debut": ...}, inte ett objekt nästlat under en params-nyckel.

Bästa praxis

Fyra vanor gör skillnad i längden. För det första, håll dig till ett ansvar per arbetsflöde: att blanda fakturering och försäljningsuppföljning i samma klass gör det omöjligt att spela upp det ena utan det andra. Var sedan uppmärksam på namngivning, eftersom arbetsflödets name är en offentlig identifierare som anropas från andra system – "traitement_commande" är underhållsbart, "workflow_1" är det inte. Introducera ingen I/O i arbetsflödet: varje nätverksanrop, filåtkomst eller databasfråga hör hemma i en aktivitet. Håll slutligen arbetsflödeskoden enkel genom att flytta komplex logik – parsning, transformationer, tunga beräkningar – till aktiviteter, där den kan testas isolerat utan determinismkrav.

Viktiga punkter

  • Ett arbetsflöde är en klass dekorerad med @workflows.workflow.define() som orkestrerar aktiviteter
  • Metoden @workflows.workflow.entrypoint är startpunkten som anropas vid uppstart
  • Varje aktivitets-await är en persistenspunkt (automatisk återupptagning vid fel)
  • Villkorliga grenar och loopar stöds
  • Använd Pydantic-modeller för strukturerade inparametrar
  • Arbetsflödet får inte innehålla några direkta I/O-operationer