Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Kør og test en workflow

Lektion 7 af 14 Opdateret 3. november 2026 Avanceret
På denne side
  1. Udløs en workflow
  2. Udløsning via Python SDK
  3. Udløsning via cURL
  4. End-to-end-eksempel
  5. Tjek resultater
  6. Håndtering af fejl
  7. Lokal test
  8. Vigtige pointer

Lektionen opdateret 3. november 2026 baseret på mistralai SDK 3.7.0: Sporing af en eksekvering bruger nu client.workflows.executions.get_workflow_execution_async, og resultatet læses fra result. Tillæg samme dag: Tidligere eksempler refererede stadig til execution.id, execution.output og execution.error, som ikke findes i SDK’et, og sammenlignede status med småt "completed" eller "failed"; de bruger nu execution_id, result, wait_for_result=True og statusser med store bogstaver. Kilde: client-python.

Udløs en workflow

Du har skrevet dine aktiviteter, defineret din workflow og startet din worker. Nu skal du igangsætte en eksekvering. Du har to muligheder: Python SDK eller et cURL-kald til REST API’et. Den første passer til dine Python-scripts og tjenester; den anden fungerer til hurtige kommandolinjetests eller udløsere fra ikke-Python-systemer – en webhook, en scheduler eller en backend skrevet i et andet sprog.

Tre betingelser skal være opfyldt, før du udløser noget som helst. Din worker skal køre (uv run python worker.py), din API-nøgle skal være sat i MISTRAL_API_KEY, og workflow’en skal være registreret hos den worker, hvilket betyder, at den optræder i listen, der sendes til run_worker().

Udløsning via Python SDK

Skriv udløseren i et script adskilt fra workeren, da worker-processen aldrig returnerer kontrollen:

import asyncio
from mistralai.client import Mistral

async def main():
    client = Mistral()

    execution = await client.workflows.execute_workflow_async(
        workflow_identifier="salutation_workflow",
        input={"nom": "Marie"},
        wait_for_result=True,  # vent på fuldførelse og modtag resultatet
    )

    print(f"Execution ID: {execution.execution_id}")
    print(f"Result: {execution.result}")

if __name__ == "__main__":
    asyncio.run(main())

workflow_identifier skal matche det name, der er deklareret i @workflows.workflow.define(), nøjagtigt, og nøglerne i input-ordbogen svarer til parametrene i din run-metode. Kør dette script i en separat terminal, mens den første er optaget af workeren:

uv run python trigger.py

Med wait_for_result=True venter SDK’et på, at eksekveringen bliver færdig, og returnerer resultatet direkte, hvilket gør test meget læsevenlige for korte workflows. Uden denne parameter returnerer kaldet øjeblikkeligt med eksekveringsidentifikatoren, som du derefter sporer (se nedenfor).

Udløsning via cURL

Til hurtige tests eller integration med andre systemer eksponerer REST API’et den samme udløser:

curl -X POST https://api.mistral.ai/v1/workflows/salutation_workflow/execute \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input": {"nom": "Marie"}, "wait_for_result": true}'

Med wait_for_result indeholder svaret workflow-navnet, eksekveringsidentifikatoren og dens resultat; dette er felterne i SDK’ets WorkflowExecutionSyncResponse-model:

{
  "workflow_name": "salutation_workflow",
  "execution_id": "…",
  "result": {
    "message": "Bonjour, Marie !"
  }
}

Behold denne execution_id: det er nøglen, du senere bruger til at spørge efter eksekveringen eller hente dens spor. Uden wait_for_result beskriver svaret den kørende eksekvering, inklusive dens status (oprindeligt RUNNING).

End-to-end-eksempel

Lad os genbesøge eksemplet på pipeline til dokumentanalyse, denne gang fuldt forbundet. Den første fil kombinerer definitionerne og worker-starten; bemærk trunkeringen til 5000 tegn, hvilket beskytter både aktivitetsstørrelsesgrænsen og dit token-budget.

Fil workflow.py (worker + definitioner)

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

@workflows.activity()
async def extraire_texte(url: str) -> dict:
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
    return {"texte": response.text[:5000]}  # Begræns til 5000 tegn

@workflows.activity()
async def resumer_texte(texte: str) -> dict:
    client = Mistral()
    response = await client.chat.complete_async(
        model="mistral-large-latest",
        messages=[
            {"role": "system", "content": "Summarize in 3 sentences."},
            {"role": "user", "content": texte}
        ]
    )
    return {"resume": response.choices[0].message.content}

@workflows.workflow.define(name="resume_page_web")
class ResumePageWeb:
    @workflows.workflow.entrypoint
    async def run(self, url: str) -> dict:
        extraction = await extraire_texte(url)
        resume = await resumer_texte(extraction["texte"])
        return {
            "url_source": url,
            "resume": resume["resume"]
        }

async def main() -> None:
    await workflows.run_worker([ResumePageWeb])

if __name__ == "__main__":
    asyncio.run(main())

Den anden fil udløser workflow’en og viser resultatet, hvor fejlsituationen håndteres eksplicit – en refleks, du skal tilegne dig fra dit første script:

Fil trigger.py (udløser)

import asyncio
from mistralai.client import Mistral

async def main():
    client = Mistral()

    print("Starter workflow...")
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier="resume_page_web",
        input={"url": "https://example.com/article"},
    )
    print(f"Eksekvering startet: {execution.execution_id}")

    # Spor eksekvering indtil fuldførelse
    while True:
        suivi = await client.workflows.executions.get_workflow_execution_async(
            execution_id=execution.execution_id
        )
        if suivi.status not in ("RUNNING", "RETRYING_AFTER_ERROR"):
            break
        await asyncio.sleep(2)

    if suivi.status == "COMPLETED":
        print(f"Resumé: {suivi.result['resume']}")
    else:
        print(f"Eksekvering afsluttet med status {suivi.status}")

if __name__ == "__main__":
    asyncio.run(main())

Eksekvering

Terminal 1 – Start workeren:

uv run python workflow.py

Terminal 2 – Udløs eksekveringen:

uv run python trigger.py

Tjek resultater

Worker-terminalen er dit første observationspunkt: den viser udførte aktiviteter i realtid sammen med deres varighed, så du straks kan se, hvilket trin der bruger mest tid.

[INFO] Executing activity: extraire_texte
[INFO] Activity completed: extraire_texte (1.2s)
[INFO] Executing activity: resumer_texte
[INFO] Activity completed: resumer_texte (3.4s)
[INFO] Workflow completed: resume_page_web

Ved lange workflows bliver du selvfølgelig ikke siddende klistret til terminalen. Når du først har eksekverings-ID’et, kan du spørge efter dens status når som helst fra en anden proces:

execution = await client.workflows.executions.get_workflow_execution_async(
    execution_id="exec_abc123"
)
print(f"Status: {execution.status}")
print(f"Result: {execution.result}")

Den samme operation er tilgængelig via cURL, hvilket er nyttigt i et overvågningsscript:

curl https://api.mistral.ai/v1/workflows/executions/exec_abc123 \
  -H "Authorization: Bearer $MISTRAL_API_KEY"

Håndtering af fejl

En fejl opstår ikke ved den første undtagelse: platformen genprøver først aktiviteten i henhold til sin genprøvningspolitik. Først når genprøvningerne er udtømte, skifter eksekveringen til statussen FAILED (SDK-statusser er med store bogstaver: RUNNING, COMPLETED, FAILED, CANCELED, TERMINATED, TIMED_OUT osv.), og din kaldende kode skal håndtere dette tilfælde i stedet for at antage, at et result altid er til stede:

execution = await client.workflows.executions.get_workflow_execution_async(
    execution_id="exec_abc123"
)

if execution.status == "FAILED":
    print(f"Eksekvering {execution.execution_id} mislykkedes")

Svaret indeholder ikke en fejlmeddelelse: årsagen fremgår af eksekveringshistorikken og loggene (get_workflow_execution_history_async, get_workflow_execution_logs_async). For at identificere den fejlbehæftede aktivitet og den sekvens, der førte til den, analyserer du OpenTelemetry-spor, som dækkes i lektion 14.

Lokal test

At shuttle mellem to terminaler bliver hurtigt kedeligt under udvikling. Til udvikling kan et enkelt script starte workeren i baggrunden, udløse workflow’en og derefter stoppe alt:

import asyncio
import mistralai.workflows as workflows

# ... definitioner af aktiviteter og workflows ...

async def main():
    # Start worker i baggrunden
    worker_task = asyncio.create_task(
        workflows.run_worker([MonWorkflow])
    )

    # Vent på at workeren er klar
    await asyncio.sleep(2)

    # Udløs workflow
    from mistralai.client import Mistral
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier="mon_workflow",
        input={"test": True},
        wait_for_result=True,
    )
    print(f"Result: {execution.result}")

    # Stop worker
    worker_task.cancel()

if __name__ == "__main__":
    asyncio.run(main())

asyncio.sleep(2) giver workeren tid til at etablere sin forbindelse før udløsning, og det sidste worker_task.cancel() forhindrer scriptet i at hænge uendeligt. Brug kun denne opsætning til udvikling: i produktion forbliver workeren og udløserne separate processer med uafhængige livscyklusser.

Vigtige pointer

  • To udløsningsmetoder: Python SDK (execute_workflow_async) og REST API (cURL)
  • Workeren skal køre, for at workflow’en kan eksekveres
  • Med wait_for_result=True venter SDK’et på fuldførelse og returnerer resultatet (result); ellers returneres execution_id til sporing
  • Brug client.workflows.executions.get_workflow_execution_async() til at tjekke en eksekverings status
  • Statusser er med store bogstaver (RUNNING, COMPLETED, FAILED osv.); årsager til fejl fremgår af eksekveringshistorik, logs og spor
  • Til udvikling kan du kombinere worker og udløser i et enkelt script ved hjælp af asyncio