Przejdź do głównej treści
Polski— Wybierz język
Menu

Uruchomienie i testowanie przepływu pracy

Lekcja 7 z 14 Zaktualizowano 3 listopada 2026 Zaawansowany
Na tej stronie
  1. Uruchomienie przepływu pracy
  2. Wyzwalanie przez Python SDK
  3. Wyzwalanie przez cURL
  4. Przykład end-to-end
  5. Sprawdzanie wyników
  6. Obsługa błędów
  7. Testowanie lokalne
  8. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 r. w oparciu o SDK mistralai w wersji 3.7.0: śledzenie wykonania odbywa się teraz za pomocą client.workflows.executions.get_workflow_execution_async, a wynik jest odczytywany z pola result. Dodatek z tego samego dnia: poprzednie przykłady nadal odwoływały się do execution.id, execution.output i execution.error, których nie ma w SDK, oraz porównywały status do małych liter "completed" lub "failed"; obecnie używają execution_id, result, wait_for_result=True oraz statusów zapisanych wielkimi literami. Źródło: client-python.

Uruchomienie przepływu pracy

Masz już zdefiniowane aktywności, stworzony przepływ pracy i uruchomionego pracownika (worker). Teraz musisz zainicjować wykonanie. Masz dwie opcje: Python SDK lub wywołanie cURL do interfejsu API REST. Pierwsze rozwiązanie idealnie wpisuje się w skrypty i usługi Pythona; drugie sprawdza się przy szybkich testach z linii poleceń lub wyzwalaniu z systemów nieopartych na Pythonie – webhooka, harmonogramu zadań czy backendu napisanego w innym języku.

Zanim cokolwiek uruchomisz, muszą zostać spełnione trzy warunki. Twój pracownik musi być uruchomiony (uv run python worker.py), klucz API musi być ustawiony w zmiennej środowiskowej MISTRAL_API_KEY, a przepływ pracy musi być zarejestrowany u tego pracownika, co oznacza, że pojawia się on na liście przekazanej do funkcji run_worker().

Wyzwalanie przez Python SDK

Napisz kod wyzwalający w skrypcie oddzielnym od pracownika, ponieważ proces pracownika nigdy nie zwraca sterowania:

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,  # czekaj na zakończenie i odbierz wynik
    )

    print(f"Execution ID: {execution.execution_id}")
    print(f"Result: {execution.result}")

if __name__ == "__main__":
    asyncio.run(main())

Wartość workflow_identifier musi dokładnie odpowiadać nazwie name zadeklarowanej w dekoratorze @workflows.workflow.define(), a klucze w słowniku input odpowiadają parametrom twojej metody run. Uruchom ten skrypt w oddzielnym terminalu, pozostawiając pierwszy zajęty przez pracownika:

uv run python trigger.py

Dzięki parametrowi wait_for_result=True SDK czeka na zakończenie wykonania i zwraca wynik bezpośrednio, co czyni testowanie bardzo czytelnym w przypadku krótkich przepływów pracy. Bez tego parametru wywołanie zwraca natychmiast identyfikator wykonania, który następnie śledzisz (patrz poniżej).

Wyzwalanie przez cURL

Do szybkich testów lub integracji z innymi systemami interfejs API REST udostępnia to samo wyzwalanie:

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}'

Przy użyciu wait_for_result odpowiedź zawiera nazwę przepływu pracy, identyfikator wykonania oraz jego wynik; są to pola modelu WorkflowExecutionSyncResponse z SDK:

{
  "workflow_name": "salutation_workflow",
  "execution_id": "…",
  "result": {
    "message": "Bonjour, Marie !"
  }
}

Zachowaj ten execution_id: to klucz, którego użyjesz później do zapytania o wykonanie lub pobrania jego śladów. Bez wait_for_result odpowiedź opisuje uruchomione wykonanie, w tym jego status (początkowo RUNNING).

Przykład end-to-end

Wróćmy do przykładu potoku analizy dokumentów, tym razem w pełni skonfigurowanego. Pierwszy plik łączy definicje z uruchomieniem pracownika; zwróć uwagę na obcięcie do 5000 znaków, co chroni zarówno limit rozmiaru aktywności, jak i Twój budżet tokenów.

Plik workflow.py (pracownik + definicje)

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]}  # Ogranicz do 5000 znaków

@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())

Drugi plik wyzwala przepływ pracy i wyświetla wynik, jawnie obsługując przypadek niepowodzenia – to odruch, który warto wyrobić sobie już przy pierwszym skrypcie:

Plik trigger.py (wyzwalacz)

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}")

    # Śledź wykonanie aż do zakończenia
    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())

Wykonanie

Terminal 1 — Uruchom pracownika:

uv run python workflow.py

Terminal 2 — Wyzwal wykonanie:

uv run python trigger.py

Sprawdzanie wyników

Terminal pracownika jest Twoim pierwszym punktem obserwacji: wyświetla wykonane aktywności w czasie rzeczywistym wraz z ich czasem trwania, co natychmiast pokazuje, który krok pochłania najwięcej czasu.

[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

W przypadku długich przepływów pracy oczywiście nie będziesz wpatrywać się w terminal. Gdy tylko masz identyfikator wykonania, możesz w dowolnym momencie zapytać o jego status z innego procesu:

execution = await client.workflows.executions.get_workflow_execution_async(
    execution_id="exec_abc123"
)
print(f"Status: {execution.status}")
print(f"Result: {execution.result}")

Ta sama operacja jest dostępna przez cURL, co przydaje się w skryptach monitorujących:

curl https://api.mistral.ai/v1/workflows/executions/exec_abc123 \
  -H "Authorization: Bearer $MISTRAL_API_KEY"

Obsługa błędów

Niepowodzenie nie następuje przy pierwszym wyjątku: platforma najpierw ponawia próbę wykonania aktywności zgodnie z jej polityką retry. Dopiero po wyczerpaniu prób ponowienia wykonanie przechodzi do statusu FAILED (statusy w SDK są zapisywane wielkimi literami: RUNNING, COMPLETED, FAILED, CANCELED, TERMINATED, TIMED_OUT itd.), a Twój kod wywołujący musi obsłużyć ten przypadek, zamiast zakładać, że result zawsze istnieje:

execution = await client.workflows.executions.get_workflow_execution_async(
    execution_id="exec_abc123"
)

if execution.status == "FAILED":
    print(f"Execution {execution.execution_id} failed")

Odpowiedź nie zawiera komunikatu o błędzie: przyczyna pojawia się w historii wykonania i logach (get_workflow_execution_history_async, get_workflow_execution_logs_async). Aby zidentyfikować wadliwą aktywność i sekwencję, która do niej doprowadziła, przeanalizujesz ślady OpenTelemetry, omówione w Lekcji 14.

Testowanie lokalne

Przełączanie się między dwoma terminalami szybko staje się uciążliwe podczas rozwoju. Do celów deweloperskich pojedynczy skrypt może uruchomić pracownika w tle, wyzwalać przepływ pracy, a następnie zatrzymać wszystko:

import asyncio
import mistralai.workflows as workflows

# ... definicje aktywności i przepływu pracy ...

async def main():
    # Uruchom pracownika w tle
    worker_task = asyncio.create_task(
        workflows.run_worker([MonWorkflow])
    )

    # Poczekaj, aż pracownik będzie gotowy
    await asyncio.sleep(2)

    # Wyzwal przepływ pracy
    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}")

    # Zatrzymaj pracownika
    worker_task.cancel()

if __name__ == "__main__":
    asyncio.run(main())

Funkcja asyncio.sleep(2) daje pracownikowi czas na nawiązanie połączenia przed wyzwoleniem, a końcowe worker_task.cancel() zapobiega zawieszeniu się skryptu w nieskończoność. Zarezerwuj tę konfigurację wyłącznie do rozwoju: w środowisku produkcyjnym pracownik i wyzwalacze pozostają oddzielnymi procesami o niezależnych cyklach życia.

Kluczowe wnioski

  • Dwie metody wyzwalania: Python SDK (execute_workflow_async) oraz REST API (cURL)
  • Pracownik musi być uruchomiony, aby przepływ pracy mógł się wykonać
  • Przy wait_for_result=True SDK czeka na zakończenie i zwraca wynik (result); w przeciwnym razie zwraca execution_id do śledzenia
  • Użyj client.workflows.executions.get_workflow_execution_async(), aby sprawdzić status wykonania
  • Statusy są zapisywane wielkimi literami (RUNNING, COMPLETED, FAILED itd.); przyczyny niepowodzeń pojawiają się w historii wykonania, logach i śladach
  • Do celów deweloperskich połącz pracownika i wyzwalacz w jednym skrypcie, używając asyncio