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

Napredni obrasci

Lekcija 11 od 14 Ažurirano 3. studenoga 2026. Napredno
Na ovoj stranici
  1. Izvan linearnih radnih tijekova
  2. Lančanje radnih tijekova
  3. Paralelizacija s asyncio.gather
  4. Donošenje odluka u radnom tijeku
  5. Fan-out / Fan-in
  6. Ključne točke

Ažurirano 3. studenog 2026.: Podradni tijek (sub-workflow) prethodno je vraćao execution.output, što nedostaje u SDK-u mistralai verzije 3.7.0. Rezultat se sada čita iz result, koristeći wait_for_result=True kako bi se pričekalo dovršetak.

Izvan linearnih radnih tijekova

Do sada smo promatrali radne tijekove koji izvršavaju aktivnosti sekvencijalno. U praksi stvarni slučajevi upotrebe zahtijevaju sofisticiranije obrasce: lančanje radnih tijekova, paralelno pokretanje aktivnosti ili donošenje složenih uvjetnih odluka. Ova četiri obrasca – lančanje, nastavak (continuation), paralelizam i fan-out/fan-in – pokrivaju gotovo svaku arhitekturu koju ćeš trebati izgraditi.

Lančanje radnih tijekova

Radni tijek može pokrenuti drugi radni tijek. Ta mogućnost služi dvama različitim ciljevima: razbijanju složene logike na ponovno upotrebljive podradne tijekove i zaobilaženju ograničenja od 51.200 događaja po izvršenju, budući da svaki podređeni radni tijek dobiva vlastiti budžet. Mehanizam se oslanja na aktivnost, jedino mjesto gdje SDK legitimno može izvršiti mrežni poziv.

import mistralai.workflows as workflows
from mistralai.client import Mistral

@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
    """Pokreće podređeni radni tijek i čeka njegov rezultat."""
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier=workflow_name,
        input=input_data,
        wait_for_result=True,  # čekaj rezultat podređenog radnog tijeka
    )
    return execution.result

@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        # Korak 1: Prikupljanje podataka (namjenski podradni tijek)
        data = await launch_sub_workflow(
            "data_collection",
            {"sources": params["sources"]}
        )

        # Korak 2: Analiza (namjenski podradni tijek)
        analysis = await launch_sub_workflow(
            "content_analysis",
            {"data": data}
        )

        # Korak 3: Generiranje izvješća (namjenski podradni tijek)
        report = await launch_sub_workflow(
            "report_generation",
            {"analysis": analysis, "format": params["format"]}
        )

        return report

Prednost nadilazi jednostavnu čitljivost: data_collection postaje samostalni radni tijek, testabilan u izolaciji i ponovno upotrebljiv od strane drugih pipelineova, s vlastitim vremenskim ograničenjima i pravilima ponovnog pokušaja.

Isti mehanizam, primijenjen na radni tijek koji poziva sam sebe, stvara obrazac nastavka (continuation). Umjesto obrade sto tisuća stavki u jednom izvršenju – što ograničenje događaja zabranjuje – radni tijek obrađuje šaržu (batch) i delegira ostatak novoj instanci.

@workflows.workflow.define(name="batch_processing")
class BatchProcessing:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        offset = params.get("offset", 0)
        batch_size = 100

        # Dohvati trenutnu šaržu
        batch = await retrieve_batch(offset, batch_size)

        if not batch["items"]:
            # Sve šarže obrađene
            return {"status": "completed", "total_processed": offset}

        # Obradi trenutnu šaržu
        await process_batch(batch["items"])

        # Pokreni sljedeću šaržu putem novog radnog tijeka
        next_batch = await launch_sub_workflow(
            "batch_processing",
            {"offset": offset + batch_size}
        )

        return next_batch

Svako novo izvršenje započinje s čistim dnevnikom (journal). Broj stavki koje se mogu obraditi postaje neograničen, pri čemu je uvjet zaustavljanja jednostavno prazna šarža.

Paralelizacija s asyncio.gather

Kada su višestruke aktivnosti međusobno neovisne, nema razloga pokretati ih sekvencijalno. asyncio.gather šalje ih platformi istovremeno, a ukupno vrijeme približava se vremenu najsporije aktivnosti, a ne zbroju svih njih.

import asyncio
import mistralai.workflows as workflows

@workflows.activity()
async def analyze_source(url: str) -> dict:
    """Analizira izvor podataka."""
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
    return {"url": url, "size": len(response.text)}

@workflows.workflow.define(name="parallel_analysis")
class ParallelAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, urls: list) -> dict:
        # Pokreni sve analize paralelno
        results = await asyncio.gather(
            *[analyze_source(url) for url in urls]
        )

        return {
            "source_count": len(results),
            "results": list(results)
        }

Postoji jedna napomena: prema zadanim postavkama, gather propagira prvu encountered iznimku i prekida cijeli skup. Ako analiziraš četrdeset vanjskih izvora, samo jedan izvan mreže uzrokuje gubitak preostalih trideset i devet. Parametar return_exceptions=True mijenja to ponašanje: pogreške se vraćaju kao obične vrijednosti, ostavljajući tebi da ih razvrstaš.

@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, urls: list) -> dict:
        # return_exceptions=True sprječava da jedna pogreška blokira ostale
        results = await asyncio.gather(
            *[analyze_source(url) for url in urls],
            return_exceptions=True
        )

        successes = []
        errors = []
        for i, result in enumerate(results):
            if isinstance(result, Exception):
                errors.append({"url": urls[i], "error": str(result)})
            else:
                successes.append(result)

        return {
            "successes": successes,
            "errors": errors,
            "success_rate": len(successes) / len(urls)
        }

Ovaj radni tijek vraća djelomični rezultat popraćen stopom uspješnosti, omogućujući nizvodnim procesima da odluče je li kvaliteta dovoljna ili je potreban ponovni pokušaj.

Donošenje odluka u radnom tijeku

Složeno grananje nije samo dopušteno, već je često i glavna svrha korištenja radnih tijekova, pod uvjetom da uvjeti proizlaze iz rezultata aktivnosti. Slučaj moderacije sadržaja dobro ilustrira ovu kaskadnu logiku: automatska odluka kada je model vrlo siguran, drugo mišljenje kada je sigurnost umjerena, i eskalacija na čovjeka u slučaju neslaganja ili niske sigurnosti.

@workflows.workflow.define(name="content_moderation")
class ContentModeration:
    @workflows.workflow.entrypoint
    async def run(self, content: dict) -> dict:
        # Korak 1: Automatska analiza
        analysis = await auto_analyze_content(content["text"])

        if analysis["confidence_score"] > 0.95:
            # Visoka sigurnost: automatska odluka
            if analysis["category"] == "acceptable":
                await publish_content(content["id"])
                return {"decision": "published", "method": "automatic"}
            else:
                await reject_content(content["id"], analysis["reason"])
                return {"decision": "rejected", "method": "automatic"}

        elif analysis["confidence_score"] > 0.7:
            # Umjerena sigurnost: druga analiza s drugačijim modelom
            second_analysis = await analyze_content_model_b(content["text"])

            if analysis["category"] == second_analysis["category"]:
                # Oba modela se slažu
                if analysis["category"] == "acceptable":
                    await publish_content(content["id"])
                    return {"decision": "published", "method": "ai_consensus"}
                else:
                    await reject_content(content["id"], analysis["reason"])
                    return {"decision": "rejected", "method": "ai_consensus"}
            else:
                # Neslaganje: eskalacija na čovjeka
                await escalate_moderation(content["id"], analysis, second_analysis)
                return {"decision": "pending", "method": "human_escalation"}

        else:
            # Niska sigurnost: izravna eskalacija
            await escalate_moderation(content["id"], analysis, None)
            return {"decision": "pending", "method": "human_escalation"}

Primijeti polje method vraćeno na svakoj izlaznoj točki: ono ti omogućuje da retrospektivno izmjeriš koji je udio sadržaja obrađen bez ljudske intervencije i sukladno tome prilagodiš pragove.

Fan-out / Fan-in

Završni obrazac kombinira prethodne: distribuiraj posao paralelno, a zatim agregiraj rezultate na jednoj točki. Ovdje se dokument istovremeno prevodi na tri jezika, svaki prijevod se analizira paralelno, a sve konvergira u sažetak.

@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, document: dict) -> dict:
        # Fan-out: paralelno prevođenje na 3 jezika
        translations = await asyncio.gather(
            translate(document["text"], "en"),
            translate(document["text"], "de"),
            translate(document["text"], "es")
        )

        # Fan-out: paralelna analiza svakog prijevoda
        analyses = await asyncio.gather(
            *[analyze_sentiment(trad["translated_text"]) for trad in translations]
        )

        # Fan-in: agregacija rezultata
        summary = await aggregate_analyses(list(analyses))

        return summary

Dva vala paralelizma su uzastopna jer drugi ovisi o rezultatima prvog. U strogoj sekvenci, ovaj radni tijek zahtijevao bi sedam lančanih poziva; ovdje košta samo tri koraka orkestracije.

Ukratko, razbij složene radne tijekove na ponovno upotrebljive podradne tijekove, paraleliziraj kad god su aktivnosti neovisne, omogući return_exceptions=True kada su djelomični neuspjesi prihvatljivi, zadrži nastavak (continuation) u rezervi za vrlo dugačke zadatke obrade i uvijek osiguraj da se tvoje grananje oslanja na rezultate aktivnosti, a ne na nedeterminističke vrijednosti.

Ključne točke

  • Radni tijek može pokrenuti druge radne tijekove putem aktivnosti koja poziva SDK
  • Obrazac nastavka (continuation) omogućuje obradu neograničenog broja stavki u uzastopnim šaržama
  • asyncio.gather omogućuje pokretanje aktivnosti paralelno kako bi se smanjilo ukupno vrijeme
  • Složeno uvjetno grananje podržano je sve dok ovisi o rezultatima aktivnosti
  • Obrazac fan-out / fan-in distribuira posao, a zatim agregira rezultate