Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Pokreni i testiraj tijek rada

Lekcija 7 od 14 Ažurirano 3. studenoga 2026. Napredno
Na ovoj stranici
  1. Pokretanje tijeka rada
  2. Pokretanje putem Python SDK-a
  3. Pokretanje putem cURL-a
  4. Primjer od kraja do kraja
  5. Provjera rezultata
  6. Rukovanje greškama
  7. Lokalno testiranje
  8. Ključne točke

Lekcija ažurirana 3. studenog 2026. na temelju SDK-a mistralai verzije 3.7.0: praćenje izvršenja sada koristi client.workflows.executions.get_workflow_execution_async, a rezultat se čita iz result. Dodatak istog dana: prethodni primjeri su se još uvijek pozivali na execution.id, execution.output i execution.error, koji ne postoje u SDK-u, te su uspoređivali status s malim slovima "completed" ili "failed"; sada koriste execution_id, result, wait_for_result=True i statusa velikim slovima. Izvor: client-python.

Pokretanje tijeka rada

Napisao si svoje aktivnosti, definirao tijek rada i pokrenuo radnika (worker). Sada moraš pokrenuti izvršenje. Imaš dvije opcije: Python SDK ili cURL poziv na REST API. Prva opcija odgovara tvojim Python skriptama i uslugama; druga služi za brza testiranja u naredbenom retku ili okidače iz sustava koji nisu napisani u Pythonu – webhook, planer (scheduler) ili backend napisan u drugom jeziku.

Prije pokretanja bilo čega, moraju biti ispunjena tri uvjeta. Tvoj radnik mora biti pokrenut (uv run python worker.py), tvoj API ključ mora biti postavljen u MISTRAL_API_KEY, a tijek rada mora biti registriran kod tog radnika, što znači da se pojavljuje na popisu proslijeđenom funkciji run_worker().

Pokretanje putem Python SDK-a

Napiši okidač u skripti odvojenoj od radnika, jer proces radnika nikada ne vraća 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,  # čekaj završetak i primi rezultat
    )

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

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

Vrijednost workflow_identifier mora točno odgovarati name deklariranom u @workflows.workflow.define(), a ključevi u rječniku input odgovaraju parametrima tvoje metode run. Pokreni ovu skriptu u zasebnom terminalu, ostavljajući prvi zauzetim od strane radnika:

uv run python trigger.py

S wait_for_result=True, SDK čeka da se izvršenje završi i izravno vraća rezultat, što testiranje čini vrlo preglednim za kratke tijekove rada. Bez ovog parametra, poziv se odmah vraća s identifikatorom izvršenja, koji zatim pratiš (vidi dolje).

Pokretanje putem cURL-a

Za brza testiranja ili integraciju s drugim sustavima, REST API izlaže isti okidač:

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 wait_for_result, odgovor sadrži naziv tijeka rada, identifikator izvršenja i njegov rezultat; to su polja modela WorkflowExecutionSyncResponse iz SDK-a:

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

Zapamti ovaj execution_id: to je ključ koji ćeš kasnije koristiti za upit o izvršenju ili dohvaćanje njegovih tragova. Bez wait_for_result, odgovor opisuje izvršenje koje je u tijeku, uključujući njegov status (inicijalno RUNNING).

Primjer od kraja do kraja

Vratimo se primjeru cjevovoda za analizu dokumenata, ovaj put u potpunosti povezanog. Prva datoteka kombinira definicije i pokretanje radnika; obrati pažnju na skraćivanje na 5000 znakova, što štiti i ograničenje veličine aktivnosti i tvoj budžet tokena.

Datoteka workflow.py (radnik + 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]}  # Ograniči na 5000 znakova

@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 pokreće tijek rada i prikazuje rezultat, eksplicitno obrađujući slučaj neuspjeha – refleks koji trebaš usvojiti već od svoje prve skripte:

Datoteka trigger.py (okidač)

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

    # Prati izvršenje do završetka
    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())

Izvršenje

Terminal 1 — Pokreni radnika:

uv run python workflow.py

Terminal 2 — Pokreni izvršenje:

uv run python trigger.py

Provjera rezultata

Terminal radnika tvoja je prva točka promatranja: prikazuje izvršene aktivnosti u stvarnom vremenu, zajedno s njihovim trajanjem, odmah ti pokazujući koji korak troši najviše vremena.

[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

Za duge tijekove rada, očito nećeš biti zalijepljen za terminal. Jednom kada imaš ID izvršenja, možeš u bilo kojem trenutku iz drugog procesa upitati njegov status:

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

Ista operacija dostupna je putem cURL-a, što je korisno u skripti za nadzor:

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

Rukovanje greškama

Neuspjeh se ne događa kod prve iznimke: platforma prvo ponovno pokušava izvršiti aktivnost prema svojoj politici ponovnog pokušaja. Tek nakon što se potroše svi ponovni pokušaji, izvršenje prelazi u status FAILED (statusi u SDK-u su velikim slovima: RUNNING, COMPLETED, FAILED, CANCELED, TERMINATED, TIMED_OUT itd.), a tvoj pozivni kod mora obraditi ovaj slučaj umjesto da pretpostavlja da je result uvijek prisutan:

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 sadrži poruku o grešci: uzrok se pojavljuje u povijesti izvršenja i zapisnicima (get_workflow_execution_history_async, get_workflow_execution_logs_async). Da bi identificirao neispravnu aktivnost i slijed koji je doveo do nje, analizirat ćeš OpenTelemetry tragove, što je obrađeno u Lekciji 14.

Lokalno testiranje

Skakanje između dva terminala brzo postaje zamorno tijekom razvoja. Za razvoj, jedna skripta može pokrenuti radnika u pozadini, okinuti tijek rada, a zatim sve zaustaviti:

import asyncio
import mistralai.workflows as workflows

# ... definicije aktivnosti i tijeka rada ...

async def main():
    # Pokreni radnika u pozadini
    worker_task = asyncio.create_task(
        workflows.run_worker([MonWorkflow])
    )

    # Pričekaj da radnik bude spreman
    await asyncio.sleep(2)

    # Pokreni tijek rada
    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}")

    # Zaustavi radnika
    worker_task.cancel()

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

asyncio.sleep(2) daje radniku vremena da uspostavi vezu prije okidanja, a konačni worker_task.cancel() sprječava beskonačno vješanje skripte. Ovaj postav rezerviraj za razvoj: u proizvodnji, radnik i okidači ostaju odvojeni procesi s neovisnim životnim ciklusima.

Ključne točke

  • Dva načina okidanja: Python SDK (execute_workflow_async) i REST API (cURL)
  • Radnik mora biti pokrenut da bi se tijek rada izvršio
  • S wait_for_result=True, SDK čeka završetak i vraća rezultat (result); inače vraća execution_id za praćenje
  • Koristi client.workflows.executions.get_workflow_execution_async() za provjeru statusa izvršenja
  • Statusi su velikim slovima (RUNNING, COMPLETED, FAILED itd.); uzroci neuspjeha pojavljuju se u povijesti izvršenja, zapisnicima i tragovima
  • Za razvoj, kombiniraj radnika i okidač u jednoj skripti koristeći asyncio