Kør og test en workflow
På denne side
Lektionen opdateret 3. november 2026 baseret på
mistralaiSDK 3.7.0: Sporing af en eksekvering bruger nuclient.workflows.executions.get_workflow_execution_async, og resultatet læses fraresult. Tillæg samme dag: Tidligere eksempler refererede stadig tilexecution.id,execution.outputogexecution.error, som ikke findes i SDK’et, og sammenlignede status med småt"completed"eller"failed"; de bruger nuexecution_id,result,wait_for_result=Trueog 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=Trueventer SDK’et på fuldførelse og returnerer resultatet (result); ellers returneresexecution_idtil sporing - Brug
client.workflows.executions.get_workflow_execution_async()til at tjekke en eksekverings status - Statusser er med store bogstaver (
RUNNING,COMPLETED,FAILEDosv.); å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