Spustit a otestovat workflow
Na této stránce
Lekce aktualizována 3. listopadu 2026 na základě SDK
mistralaiverze 3.7.0: sledování provádění nyní využíváclient.workflows.executions.get_workflow_execution_asynca výsledek se čte zresult. Dodatek ze stejného dne: předchozí příklady stále odkazovaly naexecution.id,execution.outputaexecution.error, které v SDK chybí, a porovnávaly stav s malými písmeny"completed"nebo"failed"; nyní používajíexecution_id,result,wait_for_result=Truea stavy velkými písmeny. Zdroj: client-python.
Spuštění workflow
Napsal jsi své aktivity, definoval workflow a spustil worker. Nyní musíš zahájit provádění. Máš dvě možnosti: Python SDK nebo volání cURL na REST API. První možnost se hodí pro tvé Python skripty a služby; druhá funguje pro rychlé testy z příkazové řádky nebo spouštění z nepythonovských systémů – webhooku, plánovače nebo backendu napsaného v jiném jazyce.
Před spuštěním čehokoli musíš splnit tři podmínky. Tvůj worker musí běžet (uv run python worker.py), tvůj API klíč musí být nastaven v proměnné MISTRAL_API_KEY a workflow musí být u tohoto workeru registrováno, což znamená, že se objevuje v seznamu předaném funkci run_worker().
Spuštění přes Python SDK
Spouštěcí kód napiš do skriptu odděleného od workeru, protože proces workeru nikdy nevrací řízení:
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, # čeká na dokončení a vrátí výsledek
)
print(f"Execution ID: {execution.execution_id}")
print(f"Result: {execution.result}")
if __name__ == "__main__":
asyncio.run(main())
Hodnota workflow_identifier musí přesně odpovídat name deklarovanému v @workflows.workflow.define() a klíče ve slovníku input odpovídají parametrům tvé metody run. Tento skript spusť v samostatném terminálu, přičemž první terminál nech obsazený workerem:
uv run python trigger.py
S parametrem wait_for_result=True SDK počká na dokončení provádění a vrátí výsledek přímo, což činí testování velmi přehledným pro krátká workflow. Bez tohoto parametru volání okamžitě vrátí identifikátor provádění, který poté sleduješ (viz níže).
Spuštění přes cURL
Pro rychlé testy nebo integraci s jinými systémy vystavuje REST API stejnou spouštěcí funkci:
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}'
S parametrem wait_for_result odpověď obsahuje název workflow, identifikátor provádění a jeho výsledek; toto jsou pole modelu WorkflowExecutionSyncResponse z SDK:
{
"workflow_name": "salutation_workflow",
"execution_id": "…",
"result": {
"message": "Bonjour, Marie !"
}
}
Ulož si toto execution_id: je to klíč, který později použiješ k dotazování na provádění nebo získání jeho stop. Bez wait_for_result odpověď popisuje běžící provádění, včetně jeho status (zpočátku RUNNING).
Komplexní příklad end-to-end
Podívejme se znovu na příklad pipeline pro analýzu dokumentů, tentokrát plně propojený. První soubor kombinuje definice a spuštění workeru; všimni si ořezu na 5000 znaků, který chrání jak limit velikosti aktivity, tak tvůj rozpočet tokenů.
Soubor workflow.py (worker + definice)
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]} # Omezit na 5000 znaků
@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())
Druhý soubor spouští workflow a zobrazuje výsledek, přičemž explicitně řeší případ selhání – to je reflex, který bys měl adoptovat již od svého prvního skriptu:
Soubor trigger.py (spouštěč)
import asyncio
from mistralai.client import Mistral
async def main():
client = Mistral()
print("Spouštím workflow...")
execution = await client.workflows.execute_workflow_async(
workflow_identifier="resume_page_web",
input={"url": "https://example.com/article"},
)
print(f"Provádění spuštěno: {execution.execution_id}")
# Sledování provádění až do dokončení
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"Shrnutí: {suivi.result['resume']}")
else:
print(f"Provádění skončilo se stavem {suivi.status}")
if __name__ == "__main__":
asyncio.run(main())
Provedení
Terminál 1 – Spuštění workeru:
uv run python workflow.py
Terminál 2 – Spuštění provádění:
uv run python trigger.py
Kontrola výsledků
Terminál workeru je tvým prvním bodem pozorování: zobrazuje prováděné aktivity v reálném čase spolu s jejich délkou trvání, takže okamžitě vidíš, který krok spotřebovává nejvíce času.
[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
U dlouhých workflow samozřejmě nebudeš přilepený k terminálu. Jakmile máš ID provádění, můžeš kdykoli z jiného procesu dotazovat jeho stav:
execution = await client.workflows.executions.get_workflow_execution_async(
execution_id="exec_abc123"
)
print(f"Status: {execution.status}")
print(f"Result: {execution.result}")
Stejná operace je dostupná přes cURL, což je užitečné v monitorovacích skriptech:
curl https://api.mistral.ai/v1/workflows/executions/exec_abc123 \
-H "Authorization: Bearer $MISTRAL_API_KEY"
Zpracování chyb
K selhání nedojde při první výjimce: platforma nejprve aktivitu zkusí znovu podle své politiky opakování. Teprve po vyčerpání pokusů o opakování přejde provádění do stavu FAILED (stavy v SDK jsou velkými písmeny: RUNNING, COMPLETED, FAILED, CANCELED, TERMINATED, TIMED_OUT atd.) a tvůj volající kód musí tento případ ošetřit místo toho, aby předpokládal, že result je vždy přítomen:
execution = await client.workflows.executions.get_workflow_execution_async(
execution_id="exec_abc123"
)
if execution.status == "FAILED":
print(f"Provádění {execution.execution_id} selhalo")
Odpověď neobsahuje chybovou zprávu: příčina se objevuje v historii provádění a logách (get_workflow_execution_history_async, get_workflow_execution_logs_async). Abys identifikoval chybnou aktivitu a sekvenci, která k ní vedla, analyzuješ stopy OpenTelemetry, které jsou probírány v lekci 14.
Lokální testování
Přecházení mezi dvěma terminály se během vývoje rychle stane únavným. Pro vývoj může jeden skript spustit worker na pozadí, spustit workflow a poté vše zastavit:
import asyncio
import mistralai.workflows as workflows
# ... definice aktivit a workflow ...
async def main():
# Spuštění workeru na pozadí
worker_task = asyncio.create_task(
workflows.run_worker([MonWorkflow])
)
# Čekání na připravenost workeru
await asyncio.sleep(2)
# Spuštění 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}")
# Zastavení workeru
worker_task.cancel()
if __name__ == "__main__":
asyncio.run(main())
Funkce asyncio.sleep(2) dá workeru čas navázat spojení před spuštěním a finální worker_task.cancel() zabrání tomu, aby skript visel donekonečna. Toto nastavení si rezervuj pro vývoj: v produkci zůstávají worker a spouštěče oddělenými procesy s nezávislými životními cykly.
Klíčové poznatky
- Dvě metody spuštění: Python SDK (
execute_workflow_async) a REST API (cURL) - Worker musí běžet, aby se workflow provedlo
- S
wait_for_result=TrueSDK počká na dokončení a vrátí výsledek (result); jinak vrátíexecution_idke sledování - Použij
client.workflows.executions.get_workflow_execution_async()pro kontrolu stavu provádění - Stavy jsou velkými písmeny (
RUNNING,COMPLETED,FAILEDatd.); příčiny selhání najdeš v historii provádění, logách a stopách - Pro vývoj zkombinuj worker a spouštěč do jednoho skriptu pomocí
asyncio