Izvedi in testiraj delovni tok
Na tej strani
Lekcija posodobljena 3. novembra 2026 na podlagi SDK
mistralai3.7.0: sledenje izvajanju zdaj uporabljaclient.workflows.executions.get_workflow_execution_async, rezultat pa se bere izresult. Dodatek istega dne: prejšnji primeri so se še vedno sklicevali naexecution.id,execution.outputinexecution.error, ki jih v SDK ni več, ter primerjali stanje z malimi črkami"completed"ali"failed"; zdaj uporabljajoexecution_id,result,wait_for_result=Truein stanja z velikimi črkami. Vir: client-python.
Sproži delovni tok
Napisal si svoje aktivnosti, definiral delovni tok in zagnal delavca. Zdaj moraš sprožiti izvajanje. Na voljo imaš dve možnosti: Python SDK ali klic cURL do REST API-ja. Prva možnost se prilega tvojim Python skriptam in storitvam; druga deluje za hitra testiranja v ukazni vrstici ali sprožitve iz sistemov, ki niso napisani v Pythonu – spletni kavelj (webhook), načrtovalnik ali zaledni sistem v drugem jeziku.
Preden karkoli sprožiš, morajo biti izpolnjeni trije pogoji. Tvoj delavec mora teči (uv run python worker.py), tvoj API ključ mora biti nastavljen v MISTRAL_API_KEY, delovni tok pa mora biti pri tem delavcu registriran, kar pomeni, da se pojavi na seznamu, poslanem funkciji run_worker().
Sprožitev prek Python SDK
Sprožitev zapiši v skripto, ločeno od delavca, saj proces delavca nikoli ne vrne nadzora:
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, # počakaj na zaključek in prejmi rezultat
)
print(f"Execution ID: {execution.execution_id}")
print(f"Result: {execution.result}")
if __name__ == "__main__":
asyncio.run(main())
workflow_identifier se mora točno ujemati z name, deklariranim v @workflows.workflow.define(), ključi v slovarju input pa ustrezajo parametrom tvoje metode run. To skripto zaženi v ločenem terminalu, pri čemer prvi prepusti delavcu:
uv run python trigger.py
Z wait_for_result=True SDK počaka, da se izvajanje konča, in neposredno vrne rezultat, kar omogoča zelo berljivo testiranje za kratke delovne toke. Brez tega parametra klic takoj vrne identifikator izvajanja, ki ga nato spremljaš (glej spodaj).
Sprožitev prek cURL
Za hitra testiranja ali integracijo z drugimi sistemi REST API razkriva enak sprožilec:
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}'
Z wait_for_result odgovor vsebuje ime delovnega toka, identifikator izvajanja in njegov rezultat; to so polja modela WorkflowExecutionSyncResponse v SDK-ju:
{
"workflow_name": "salutation_workflow",
"execution_id": "…",
"result": {
"message": "Bonjour, Marie !"
}
}
Ta execution_id si zapomni: to je ključ, ki ga boš kasneje uporabil za poizvedbo o izvajanju ali pridobitev njegovih sledi. Brez wait_for_result odgovor opiše tekoče izvajanje, vključno z njegovim status (sprva RUNNING).
Primer od začetka do konca
Ponovno si oglejmo primer cevovoda za analizo dokumentov, tokrat v celoti povezanega. Prva datoteka združuje definicije in zagon delavca; upoštevaj obrezovanje na 5000 znakov, kar ščiti tako omejitev velikosti aktivnosti kot tvoj proračun žetonov.
Datoteka workflow.py (delavec + definicije)
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]} # Omeji 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())
Druga datoteka sproži delovni tok in prikaže rezultat, pri čemer eksplicitno obravnava primer napake – refleks, ki ga moraš usvojiti že pri prvi skripti:
Datoteka trigger.py (sprožilec)
import asyncio
from mistralai.client import Mistral
async def main():
client = Mistral()
print("Launching workflow...")
execution = await client.workflows.execute_workflow_async(
workflow_identifier="resume_page_web",
input={"url": "https://example.com/article"},
)
print(f"Execution launched: {execution.execution_id}")
# Spremljaj izvajanje do zaključka
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"Summary: {suivi.result['resume']}")
else:
print(f"Execution finished with status {suivi.status}")
if __name__ == "__main__":
asyncio.run(main())
Izvajanje
Terminal 1 – Zaženi delavca:
uv run python workflow.py
Terminal 2 – Sproži izvajanje:
uv run python trigger.py
Preveri rezultate
Terminal delavca je tvoja prva opazovalna točka: v realnem času prikazuje izvedene aktivnosti skupaj z njihovo trajanjem, kar ti takoj pokaže, kateri korak porabi največ časa.
[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 dolgih delovnih tokovih seveda ne boš stalno zrl v terminal. Ko imaš ID izvajanja, lahko kadar koli iz drugega procesa poizveš njegovo stanje:
execution = await client.workflows.executions.get_workflow_execution_async(
execution_id="exec_abc123"
)
print(f"Status: {execution.status}")
print(f"Result: {execution.result}")
Enaka operacija je na voljo prek cURL, kar je uporabno v skripti za nadzor:
curl https://api.mistral.ai/v1/workflows/executions/exec_abc123 \
-H "Authorization: Bearer $MISTRAL_API_KEY"
Obravnava napak
Do napake ne pride ob prvi izjemi: platforma najprej ponovno poskusi aktivnost v skladu s svojo politiko ponovnih poskusov. Šele ko so ponovni poskusi izčrpani, se izvajanje premakne v stanje FAILED (stanja v SDK so z velikimi črkami: RUNNING, COMPLETED, FAILED, CANCELED, TERMINATED, TIMED_OUT itd.) in tvoja kličoča koda mora obravnavati ta primer, namesto da bi predpostavljala, da je result vedno prisoten:
execution = await client.workflows.executions.get_workflow_execution_async(
execution_id="exec_abc123"
)
if execution.status == "FAILED":
print(f"Execution {execution.execution_id} failed")
Odgovor ne vsebuje sporočila o napaki: vzrok se pojavi v zgodovini izvajanja in dnevnikih (get_workflow_execution_history_async, get_workflow_execution_logs_async). Da bi natančno določil okvaro aktivnost in zaporedje, ki je do nje pripeljalo, boš analiziral sledi OpenTelemetry, kar je obravnavano v lekciji 14.
Lokalno testiranje
Med razvojem hitro postane dolgočasno skakati med dvema terminaloma. Za razvoj lahko ena sama skripta zažene delavca v ozadju, sproži delovni tok in nato vse ustavi:
import asyncio
import mistralai.workflows as workflows
# ... definicije aktivnosti in delovnega toka ...
async def main():
# Zaženi delavca v ozadju
worker_task = asyncio.create_task(
workflows.run_worker([MonWorkflow])
)
# Počakaj, da je delavec pripravljen
await asyncio.sleep(2)
# Sproži delovni tok
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}")
# Ustavi delavca
worker_task.cancel()
if __name__ == "__main__":
asyncio.run(main())
asyncio.sleep(2) da delavcu čas, da vzpostavi povezavo pred sprožitvijo, končni worker_task.cancel() pa prepreči, da bi se skripta neskončno obesila. To nastavitev uporabi samo za razvoj: v proizvodnem okolju delavec in sprožilci ostanejo ločeni procesi z neodvisnimi življenjskimi cikli.
Ključne ugotovitve
- Dve metodi sprožitve: Python SDK (
execute_workflow_async) in REST API (cURL) - Delavec mora teči, da se delovni tok izvede
- Z
wait_for_result=TrueSDK počaka na zaključek in vrne rezultat (result); sicer vrneexecution_idza sledenje - Za preverjanje stanja izvajanja uporabi
client.workflows.executions.get_workflow_execution_async() - Stanja so zapisana z velikimi črkami (
RUNNING,COMPLETED,FAILEDitd.); vzroki za napake so v zgodovini izvajanja, dnevnikih in sledeh - Za razvoj združi delavca in sprožilec v eno skripto z uporabo
asyncio