Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Izvedi in testiraj delovni tok

Lekcija 7 od 14 Posodobljeno 3. november 2026 Napredni
Na tej strani
  1. Sproži delovni tok
  2. Sprožitev prek Python SDK
  3. Sprožitev prek cURL
  4. Primer od začetka do konca
  5. Preveri rezultate
  6. Obravnava napak
  7. Lokalno testiranje
  8. Ključne ugotovitve

Lekcija posodobljena 3. novembra 2026 na podlagi SDK mistralai 3.7.0: sledenje izvajanju zdaj uporablja client.workflows.executions.get_workflow_execution_async, rezultat pa se bere iz result. Dodatek istega dne: prejšnji primeri so se še vedno sklicevali na execution.id, execution.output in execution.error, ki jih v SDK ni več, ter primerjali stanje z malimi črkami "completed" ali "failed"; zdaj uporabljajo execution_id, result, wait_for_result=True in 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=True SDK počaka na zaključek in vrne rezultat (result); sicer vrne execution_id za sledenje
  • Za preverjanje stanja izvajanja uporabi client.workflows.executions.get_workflow_execution_async()
  • Stanja so zapisana z velikimi črkami (RUNNING, COMPLETED, FAILED itd.); vzroki za napake so v zgodovini izvajanja, dnevnikih in sledeh
  • Za razvoj združi delavca in sprožilec v eno skripto z uporabo asyncio