Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Pokročilé vzory

Lekce 11 z 14 Aktualizováno 3. listopadu 2026 Pokročilý
Na této stránce
  1. Mimo lineární workflowny
  2. Řetězení workflow
  3. Paralelizace pomocí asyncio.gather
  4. Rozhodování ve workflow
  5. Fan-out / Fan-in
  6. Klíčové poznatky

Aktualizováno 3. listopadu 2026: Podřízený workflow dříve vracel execution.output, což v SDK mistralai verze 3.7.0 chybí. Výsledek se nyní čte z result s použitím wait_for_result=True pro čekání na dokončení.

Mimo lineární workflowny

Doposud jsme se zabývali workflowny, které spouštějí aktivity sekvenčně. V praxi však reálné případy použití vyžadují sofistikovanější vzory: řetězení workflow, paralelní spouštění aktivit nebo složité podmíněné rozhodování. Tyto čtyři vzory – řetězení, pokračování, paralelismus a fan-out/fan-in – pokrývají téměř každou architekturu, kterou budeš potřebovat postavit.

Řetězení workflow

Workflow může spustit jiné workflow. Tato schopnost slouží dvěma odlišným cílům: rozdělení složité logiky na znovu použitelná podřízená workflow a obejití limitu 51 200 událostí na jedno spuštění, protože každé podřízené workflow získává vlastní rozpočet. Mechanismus spoléhá na aktivitu, což je jediné místo, kde může SDK legitimně provést síťový požadavek.

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

@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
    """Spustí podřízené workflow a počká na jeho výsledek."""
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier=workflow_name,
        input=input_data,
        wait_for_result=True,  # čekání na výsledek podřízeného workflow
    )
    return execution.result

@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        # Krok 1: Sběr dat (vyhrazené podřízené workflow)
        data = await launch_sub_workflow(
            "data_collection",
            {"sources": params["sources"]}
        )

        # Krok 2: Analýza (vyhrazené podřízené workflow)
        analysis = await launch_sub_workflow(
            "content_analysis",
            {"data": data}
        )

        # Krok 3: Generování reportu (vyhrazené podřízené workflow)
        report = await launch_sub_workflow(
            "report_generation",
            {"analysis": analysis, "format": params["format"]}
        )

        return report

Přínos přesahuje pouhou čitelnost: data_collection se stává samostatným workflow, testovatelným v izolaci a znovu použitelným jinými pipeline, s vlastními časovými limity a zásadami opakování.

Stejný mechanismus, aplikovaný na workflow, které volá samo sebe, vytváří vzor pokračování (continuation). Místo zpracování sta tisíc položek v jediném spuštění – což limit událostí zakazuje – workflow zpracuje dávku a zbytek deleguje na novou 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

        # Získání aktuální dávky
        batch = await retrieve_batch(offset, batch_size)

        if not batch["items"]:
            # Všechny dávky zpracovány
            return {"status": "completed", "total_processed": offset}

        # Zpracování aktuální dávky
        await process_batch(batch["items"])

        # Spuštění další dávky prostřednictvím nového workflow
        next_batch = await launch_sub_workflow(
            "batch_processing",
            {"offset": offset + batch_size}
        )

        return next_batch

Každé nové spuštění začíná s čistým žurnálem. Počet zpracovatelných položek se stává neomezeným, přičemž podmínkou ukončení je jednoduše prázdná dávka.

Paralelizace pomocí asyncio.gather

Když jsou na sobě různé aktivity nezávislé, není důvod je spouštět sekvenčně. asyncio.gather je odešle na platformu současně a celkový čas se přiblíží času nejpomalejší aktivity, nikoli součtu všech dohromady.

import asyncio
import mistralai.workflows as workflows

@workflows.activity()
async def analyze_source(url: str) -> dict:
    """Analyzuje datový zdroj."""
    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:
        # Spuštění všech analýz paralelně
        results = await asyncio.gather(
            *[analyze_source(url) for url in urls]
        )

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

Existuje však jedno upozornění: ve výchozím nastavení gather propaguje první encountered výjimku a přeruší celou sadu. Pokud analyzuješ čtyřicet externích zdrojů, stačí, aby byl jeden offline, a přijdeš o ostatních třicet devět. Parametr return_exceptions=True toto chování změní: chyby jsou vráceny jako běžné hodnoty a je na tobě, abys je zpracoval.

@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, urls: list) -> dict:
        # return_exceptions=True zabrání tomu, aby jedna chyba zablokovala ostatní
        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)
        }

Tento workflow vrací částečný výsledek doprovázený mírou úspěšnosti, což umožňuje downstream procesům rozhodnout, zda je kvalita dostatečná, nebo zda je potřeba opakování.

Rozhodování ve workflow

Složité větvení není pouze povoleno, ale často je hlavním důvodem použití workflow, za předpokladu, že podmínky vycházejí z výsledků aktivit. Případ moderování obsahu toto kaskádové logiku dobře ilustruje: automatické rozhodnutí, když je model vysoce přesvědčený, druhý názor při střední důvěře a eskalace na člověka v případě neshody nebo nízké důvěry.

@workflows.workflow.define(name="content_moderation")
class ContentModeration:
    @workflows.workflow.entrypoint
    async def run(self, content: dict) -> dict:
        # Krok 1: Automatická analýza
        analysis = await auto_analyze_content(content["text"])

        if analysis["confidence_score"] > 0.95:
            # Vysoká důvěra: automatické rozhodnutí
            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:
            # Střední důvěra: druhá analýza s jiným modelem
            second_analysis = await analyze_content_model_b(content["text"])

            if analysis["category"] == second_analysis["category"]:
                # Obě modely se shodují
                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:
                # Neshoda: eskalace na člověka
                await escalate_moderation(content["id"], analysis, second_analysis)
                return {"decision": "pending", "method": "human_escalation"}

        else:
            # Nízká důvěra: přímá eskalace
            await escalate_moderation(content["id"], analysis, None)
            return {"decision": "pending", "method": "human_escalation"}

Všimni si pole method vráceného v každém bodě ukončení: umožňuje ti zpětně měřit, jaká část obsahu byla zpracována bez zásahu člověka, a podle toho upravovat prahové hodnoty.

Fan-out / Fan-in

Poslední vzor kombinuje předchozí: distribuce práce paralelně a následná agregace výsledků v jediném bodě. Zde je dokument současně přeložen do tří jazyků, každý překlad je paralelně analyzován a vše konverguje do shrnutí.

@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, document: dict) -> dict:
        # Fan-out: paralelní překlad do 3 jazyků
        translations = await asyncio.gather(
            translate(document["text"], "en"),
            translate(document["text"], "de"),
            translate(document["text"], "es")
        )

        # Fan-out: paralelní analýza každého překladu
        analyses = await asyncio.gather(
            *[analyze_sentiment(trad["translated_text"]) for trad in translations]
        )

        # Fan-in: agregace výsledků
        summary = await aggregate_analyses(list(analyses))

        return summary

Obě vlny paralelismu jsou po sobě jdoucí, protože druhá závisí na výsledcích první. V přísné sekvenci by tento workflow vyžadoval sedm řetězených volání; zde stojí pouze tři kroky orchestrace.

Stručně řečeno: rozděl složité workflowny na znovu použitelná podřízená workflow, paralelizuj, kdykoli jsou aktivity nezávislé, povol return_exceptions=True, když jsou částečné selhání přijatelná, měj vzor pokračování v záloze pro velmi dlouhé úlohy zpracování a vždy se ujisti, že tvé větvení spoléhá na výsledky aktivit, nikoli na nedeterministické hodnoty.

Klíčové poznatky

  • Workflow může spouštět jiná workflow prostřednictvím aktivity, která volá SDK
  • Vzor pokračování (continuation) umožňuje zpracovávat neomezený počet položek v postupných dávkách
  • asyncio.gather ti umožňuje spouštět aktivity paralelně a snížit tak celkový čas
  • Složité podmíněné větvení je podporováno, pokud závisí na výsledcích aktivit
  • Vzor fan-out / fan-in distribuuje práci a následně agreguje výsledky