Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Spustiť a otestovať workflow

Lekcia 7 z 14 Aktualizované 3. novembra 2026 Pokročilý
Na tejto strane
  1. Spustenie workflow
  2. Spustenie cez Python SDK
  3. Spustenie cez cURL
  4. Komplexný príklad od začiatku do konca
  5. Kontrola výsledkov
  6. Ošetrenie chýb
  7. Lokálne testovanie
  8. Kľúčové poznatky

Lekcia aktualizovaná 3. novembra 2026 na základe SDK mistralai 3.7.0: sledovanie vykonania teraz používa client.workflows.executions.get_workflow_execution_async a výsledok sa číta z result. Doplnok z toho istého dňa: predchádzajúce príklady stále odkazovali na execution.id, execution.output a execution.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=True a 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=True SDK počká na dokončenie a vráti výsledok (result); inak vráti execution_id na sledovanie
  • Na kontrolu stavu vykonania použi client.workflows.executions.get_workflow_execution_async()
  • Stavy sú veľkými písmenami (RUNNING, COMPLETED, FAILED atď.); 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