Uruchomienie i testowanie przepływu pracy
Na tej stronie
Lekcja zaktualizowana 3 listopada 2026 r. w oparciu o SDK
mistralaiw wersji 3.7.0: śledzenie wykonania odbywa się teraz za pomocąclient.workflows.executions.get_workflow_execution_async, a wynik jest odczytywany z polaresult. Dodatek z tego samego dnia: poprzednie przykłady nadal odwoływały się doexecution.id,execution.outputiexecution.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=Trueoraz 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=TrueSDK czeka na zakończenie i zwraca wynik (result); w przeciwnym razie zwracaexecution_iddo śledzenia - Użyj
client.workflows.executions.get_workflow_execution_async(), aby sprawdzić status wykonania - Statusy są zapisywane wielkimi literami (
RUNNING,COMPLETED,FAILEDitd.); 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