Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Opret et workflow

Lektion 5 af 14 Opdateret 2. november 2026 Avanceret
På denne side
  1. Workflowets rolle
  2. Workflow-struktur
  3. Komplet eksempel: behandlingspipeline
  4. Workflow-holdbarhed
  5. Workflow med betinget forgrening
  6. Input med Pydantic
  7. Bedste praksis
  8. Vigtige pointer

Workflowets rolle

Workflowet er dit applikations orkestreringslag. Det definerer, hvad der skal ske, i hvilken rækkefølge og under hvilke betingelser – uden selv at udføre arbejdet. Konkret koordinerer det aktiviteter, venter på eksterne begivenheder, styrer timere og betingede grene, men det rører aldrig netværket eller disken.

Du kan opsummere dette i én sætning, som du skal huske hver gang, du gennemgår kode: aktiviteter udfører arbejdet, workflowet dirigerer. Hvis du ser httpx eller open() inde i en workflow-klasse, skal noget flyttes.

Workflow-struktur

Et workflow er en Python-klasse dekoreret med @workflows.workflow.define(), der indeholder en indgangsmetode dekoreret 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

Dekoratoren @workflows.workflow.define(name="...") registrerer klassen som et workflow. Det name, den modtager, er den unikke identifikator, du vil bruge til at udløse en kørsel – det er denne streng, ikke Python-klassenavnet, som kalderen ser. Dekoratoren @workflows.workflow.entrypoint markerer den metode, der kaldes ved opstart. Den første parameter, self, forbliver klasseinstansen som i ethvert Python-objekt, og hvert aktivitetskald bruger await.

Komplet eksempel: behandlingspipeline

Her er et realistisk workflow, der orkestrerer flere aktiviteter til at behandle et dokument. Bemærk arbejdsdelingen: de tre funktioner øverst indeholder al den kode, der rører omverdenen, mens klassen nederst blot kæder await-kald sammen og samler et 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"]
        }

Hvert await i workflowet udgør et persistenspunkt. Det er værd at verificere dette mentalt med eksemplet ovenfor: hvis processen fejler mellem trin 2 og trin 3, vil dokumentet ikke blive downloadet igen, og modellen vil ikke blive kaldt igen – så ingen ekstra token-omkostninger. Workflowet vil genoptage direkte ved gemme-trinnet.

Workflow-holdbarhed

Workflows overlever genstarter, infrastrukturfejl og midlertidige fejl, fordi platformen registrerer hver begivenhed og genopbygger workflow-tilstanden under afspilning. Denne genopbygning er kun pålidelig under én betingelse, som nævnt tidligere: workflow-koden skal altid producere den samme sekvens af operationer for de samme input. Dette er determinisme-begrænsningen. Vi vil dække detaljerne i lektion 8.

Workflow med betinget forgrening

Et workflow er ikke begrænset til en lineær sekvens. Det kan indeholde betinget logik, som i dette eksempel på ordrebehandling, hvor stien afhænger af 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-grene er fuldt understøttet. Den eneste begrænsning vedrører det materiale, der bruges til beslutningen: grenens udfald skal afhænge af returværdien fra en aktivitet – en værdi registreret i loggen og afspillet identisk – ikke på et direkte kald til en ekstern tjeneste fra workflowet. Her spørger verifier_stock til lagerbeholdningen inden for en aktivitet, og if-sætningen læser kun en ordbog, der allerede er blevet persistert.

Input med Pydantic

Et workflow, der tager seks positionelle parametre, bliver hurtigt ulæseligt. Til strukturerede input skal du bruge Pydantic-modeller, som også giver typevalidering ved starten af kørslen:

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"]}

Et punkt, du skal være opmærksom på, når du udløser dette workflow: når du bruger en BaseModel, bliver felterne til topniveaunøgler i det JSON-input, der sendes til workflowet. Du vil sende {"type_rapport": ..., "date_debut": ...}, ikke et objekt indlejret under en params-nøgle.

Bedste praksis

Fire vaner gør en forskel på lang sigt. Først og fremmest: hold dig til ét ansvar pr. workflow. At blande fakturering og salgsopfølgning i samme klasse gør det umuligt at afspille det ene uden det andet. Vær derefter opmærksom på navngivning, da workflowets name er en offentlig identifikator, der kaldes fra andre systemer – "traitement_commande" er vedligeholdelsesvenligt, "workflow_1" er det ikke. Introducer ingen I/O i workflowet: ethvert netværkskald, filadgang eller databaseforespørgsel hører hjemme i en aktivitet. Hold endelig workflow-koden simpel ved at outsorce kompleks logik – parsing, transformationer, tunge beregninger – til aktiviteter, hvor den kan testes isoleret uden determinisme-begrænsninger.

Vigtige pointer

  • Et workflow er en klasse dekoreret med @workflows.workflow.define(), der orkestrerer aktiviteter
  • Metoden @workflows.workflow.entrypoint er indgangspunktet, der kaldes ved opstart
  • Hvert aktivitets-await er et persistenspunkt (automatisk genoptagelse ved fejl)
  • Betingede grene og løkker er understøttet
  • Brug Pydantic-modeller til strukturerede inputparametre
  • Workflowet må ikke indeholde direkte I/O-operationer