Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Spustit a otestovat workflow

Lekce 7 z 14 Aktualizováno 3. listopadu 2026 Pokročilý
Na této stránce
  1. Spuštění workflow
  2. Spuštění přes Python SDK
  3. Spuštění přes cURL
  4. Komplexní příklad end-to-end
  5. Kontrola výsledků
  6. Zpracování chyb
  7. Lokální testování
  8. Klíčové poznatky

Lekce aktualizována 3. listopadu 2026 na základě SDK mistralai verze 3.7.0: sledování provádění nyní využívá client.workflows.executions.get_workflow_execution_async a výsledek se čte z result. Dodatek ze stejného dne: předchozí příklady stále odkazovaly na execution.id, execution.output a execution.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=True a 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=True SDK počká na dokončení a vrátí výsledek (result); jinak vrátí execution_id ke 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, FAILED atd.); 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