Spustiť a otestovať workflow
Na tejto strane
Lekcia aktualizovaná 3. novembra 2026 na základe SDK
mistralai3.7.0: sledovanie vykonania teraz používaclient.workflows.executions.get_workflow_execution_asynca výsledok sa číta zresult. Doplnok z toho istého dňa: predchádzajúce príklady stále odkazovali naexecution.id,execution.outputaexecution.error, ktoré v SDK chýbajú, a porovnávali stav s malými písmenami"completed"alebo"failed"; teraz používajúexecution_id,result,wait_for_result=Truea stavy s veľkými písmenami. Zdroj: client-python.
Spustenie workflow
Napísal si svoje aktivity, definoval workflow a spustil worker. Teraz musíš spustiť vykonanie. Máš dve možnosti: Python SDK alebo volanie cURL na REST API. Prvá možnosť sa hodí do tvojich Python skriptov a služieb; druhá funguje pre rýchle testy z príkazového riadku alebo spúšťače z nepythonovských systémov – webhook, plánovač alebo backend napísaný v inom jazyku.
Pred spustením čohokoľvek musia byť splnené tri podmienky. Tvoj worker musí bežať (uv run python worker.py), tvoj API kľúč musí byť nastavený v MISTRAL_API_KEY a workflow musí byť registrované u tohto workeru, čo znamená, že sa objavuje v zozname odovzdanom funkcii run_worker().
Spustenie cez Python SDK
Napíš spúšťač do skriptu oddeleného od workeru, keďže proces workeru nikdy nevráti kontrolu:
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, # čakaj na dokončenie a prijmi výsledok
)
print(f"Execution ID: {execution.execution_id}")
print(f"Result: {execution.result}")
if __name__ == "__main__":
asyncio.run(main())
Hodnota workflow_identifier musí presne zodpovedať name deklarovanému v @workflows.workflow.define() a kľúče v slovníku input zodpovedajú parametrom tvojej metódy run. Tento skript spusti v samostatnom termináli, pričom prvý nechaj obsadený workerom:
uv run python trigger.py
S parametrom wait_for_result=True SDK počká na dokončenie vykonania a vráti výsledok priamo, čo robí testovanie krátkych workflow veľmi čitateľným. Bez tohto parametra volanie vráti okamžite identifikátor vykonania, ktorý potom sleduješ (pozri nižšie).
Spustenie cez cURL
Pre rýchle testy alebo integráciu s inými systémami vystavuje REST API rovnaký spúšťač:
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 parametrom wait_for_result odpoveď obsahuje názov workflow, identifikátor vykonania a jeho výsledok; toto sú polia modelu WorkflowExecutionSyncResponse z SDK:
{
"workflow_name": "salutation_workflow",
"execution_id": "…",
"result": {
"message": "Bonjour, Marie !"
}
}
Ulož si toto execution_id: je to kľúč, ktorý neskôr použiješ na dotazovanie vykonania alebo získanie jeho stôp. Bez wait_for_result odpoveď popisuje bežiace vykonanie, vrátane jeho status (spočiatku RUNNING).
Komplexný príklad od začiatku do konca
Vráťme sa k príkladu pipeline na analýzu dokumentov, tentoraz plne prepojeného. Prvý súbor kombinuje definície a spustenie workeru; všimni si orezanie na 5000 znakov, čo chráni limit veľkosti aktivity aj tvoj rozpočet tokenov.
Súbor workflow.py (worker + definície)
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]} # Limit na 5000 znakov
@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ý súbor spúšťa workflow a zobrazuje výsledok, pričom explicitne ošetruje prípad zlyhania – reflex, ktorý si máš osvojiť už od prvého skriptu:
Súbor trigger.py (spúšťač)
import asyncio
from mistralai.client import Mistral
async def main():
client = Mistral()
print("Spúšťam workflow...")
execution = await client.workflows.execute_workflow_async(
workflow_identifier="resume_page_web",
input={"url": "https://example.com/article"},
)
print(f"Vykonanie spustené: {execution.execution_id}")
# Sleduj vykonanie až do dokončenia
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"Zhrnutie: {suivi.result['resume']}")
else:
print(f"Vykonanie skončilo so stavom {suivi.status}")
if __name__ == "__main__":
asyncio.run(main())
Vykonanie
Terminál 1 – Spusti worker:
uv run python workflow.py
Terminál 2 – Spusti vykonanie:
uv run python trigger.py
Kontrola výsledkov
Terminál workeru je tvoj prvý bod pozorovania: zobrazuje vykonané aktivity v reálnom čase spolu s ich trvaním, čo ti okamžite ukáže, ktorý krok spotrebúva najviac č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
Pri dlhých workflow samozrejme nebudeš prilepený k terminálu. Akonáhle máš ID vykonania, môžeš kedykoľvek z iného procesu zistiť 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}")
Rovnaká operácia je dostupná cez cURL, čo sa hodí v monitorovacom skripte:
curl https://api.mistral.ai/v1/workflows/executions/exec_abc123 \
-H "Authorization: Bearer $MISTRAL_API_KEY"
Ošetrenie chýb
K zlyhaniu nedochádza pri prvej výnimke: platforma najprv aktivitu opakuje podľa jej politiky opakovaní. Až po vyčerpaní opakovaní prejde vykonanie do stavu FAILED (stavy v SDK sú veľkými písmenami: RUNNING, COMPLETED, FAILED, CANCELED, TERMINATED, TIMED_OUT atď.) a tvoj volací kód musí tento prípad ošetriť namiesto predpokladu, že result je vždy prítomný:
execution = await client.workflows.executions.get_workflow_execution_async(
execution_id="exec_abc123"
)
if execution.status == "FAILED":
print(f"Vykonanie {execution.execution_id} zlyhalo")
Odpoveď neobsahuje chybovú správu: príčina sa objaví v histórii vykonania a logoch (get_workflow_execution_history_async, get_workflow_execution_logs_async). Na identifikáciu chybovej aktivity a sekvencie, ktorá k nej viedla, analyzuješ stopy OpenTelemetry, ktoré sú pokryté v lekcii 14.
Lokálne testovanie
Prechádzanie medzi dvoma terminálmi sa počas vývoja rýchlo stane únavným. Pre vývoj môže jeden skript spustiť worker na pozadí, spustiť workflow a potom všetko zastaviť:
import asyncio
import mistralai.workflows as workflows
# ... definície aktivít a workflow ...
async def main():
# Spusti worker na pozadí
worker_task = asyncio.create_task(
workflows.run_worker([MonWorkflow])
)
# Počkaj, kým bude worker pripravený
await asyncio.sleep(2)
# Spusti 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}")
# Zastav worker
worker_task.cancel()
if __name__ == "__main__":
asyncio.run(main())
Funkcia asyncio.sleep(2) dá workeru čas na nadviazanie spojenia pred spustením a finálne worker_task.cancel() zabráni tomu, aby skript visel donekonečna. Toto nastavenie si vyhrad pre vývoj: v produkcii zostávajú worker a spúšťače oddelenými procesmi s nezávislými životnými cyklami.
Kľúčové poznatky
- Dve metódy spustenia: Python SDK (
execute_workflow_async) a REST API (cURL) - Worker musí bežať, aby sa workflow vykonalo
- S
wait_for_result=TrueSDK počká na dokončenie a vráti výsledok (result); inak vrátiexecution_idna sledovanie - Na kontrolu stavu vykonania použi
client.workflows.executions.get_workflow_execution_async() - Stavy sú veľkými písmenami (
RUNNING,COMPLETED,FAILEDatď.); príčiny zlyhania sa objavujú v histórii vykonania, logoch a stopách - Pre vývoj skombinuj worker a spúšťač do jedného skriptu pomocou
asyncio