Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Pokročilé vzory

Lekcia 11 z 14 Aktualizované 3. novembra 2026 Pokročilý
Na tejto strane
  1. Mimo lineárnych pracovných tokov
  2. Reťazenie pracovných tokov
  3. Paralelizácia pomocou asyncio.gather
  4. Rozhodovanie v pracovnom toku
  5. Fan-out / Fan-in
  6. Kľúčové poznatky

Aktualizované 3. novembra 2026: Podpracovný tok predtým vracal execution.output, čo v SDK mistralai verzii 3.7.0 chýba. Výsledok sa teraz číta z result s použitím wait_for_result=True na čakanie na dokončenie.

Mimo lineárnych pracovných tokov

Doteraz sme sa pozerali na pracovné toky, ktoré vykonávajú aktivity sekvenčne. V praxi si reálne prípady použitia vyžadujú sofistikovanejšie vzory: reťazenie pracovných tokov, paralelné spúšťanie aktivít alebo zložité podmienené rozhodovania. Tieto štyri vzory – reťazenie, pokračovanie, paralelizmus a fan-out/fan-in – pokrývajú takmer každú architektúru, ktorú budeš potrebovať vytvoriť.

Reťazenie pracovných tokov

Pracovný tok môže spustiť iný pracovný tok. Táto schopnosť slúži dvom odlišným cieľom: rozdeleniu zložitej logiky na opätovne použiteľné podpracovné toky a obídeniu limitu 51 200 udalostí na jedno vykonanie, keďže každý dcérsky pracovný tok dostáva vlastný rozpočet. Mechanizmus sa spolieha na aktivitu, čo je jediné miesto, kde môže SDK legitímne uskutočniť sieťové volanie.

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í dcérsky pracovný tok a počká na jeho výsledok."""
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier=workflow_name,
        input=input_data,
        wait_for_result=True,  # čakanie na výsledok dcérskeho pracovného toku
    )
    return execution.result

@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        # Krok 1: Zber dát (vyhradený podpracovný tok)
        data = await launch_sub_workflow(
            "data_collection",
            {"sources": params["sources"]}
        )

        # Krok 2: Analýza (vyhradený podpracovný tok)
        analysis = await launch_sub_workflow(
            "content_analysis",
            {"data": data}
        )

        # Krok 3: Generovanie správy (vyhradený podpracovný tok)
        report = await launch_sub_workflow(
            "report_generation",
            {"analysis": analysis, "format": params["format"]}
        )

        return report

Prínos presahuje jednoduchú čitateľnosť: data_collection sa stáva samostatným pracovným tokom, testovateľným v izolácii a opätovne použiteľným inými pipeline, s vlastnými časovými limitmi a politikami opakovania.

Ten istý mechanizmus, aplikovaný na pracovný tok, ktorý volá sám seba, vytvára vzor pokračovania. Namiesto spracovania stotisíc položiek v jednom vykonaní – čo limit udalostí zakazuje – pracovný tok spracuje dávku a zvyšok deleguje na novú inštanciu.

@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ískanie aktuálnej dávky
        batch = await retrieve_batch(offset, batch_size)

        if not batch["items"]:
            # Všetky dávky spracované
            return {"status": "completed", "total_processed": offset}

        # Spracovanie aktuálnej dávky
        await process_batch(batch["items"])

        # Spustenie ďalšej dávky cez nový pracovný tok
        next_batch = await launch_sub_workflow(
            "batch_processing",
            {"offset": offset + batch_size}
        )

        return next_batch

Každé nové vykonanie začína s čistým žurnálom. Počet spracovateľných položiek sa stáva neobmedzeným, pričom podmienkou zastavenia je jednoducho prázdna dávka.

Paralelizácia pomocou asyncio.gather

Keď sú viaceré aktivity navzájom nezávislé, nie je dôvod spúšťať ich postupne. asyncio.gather ich odovzdá platforme súčasne a celkový čas sa približuje času najpomalšej aktivity, namiesto súčtu všetkých.

import asyncio
import mistralai.workflows as workflows

@workflows.activity()
async def analyze_source(url: str) -> dict:
    """Analyzuje zdroj dát."""
    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:
        # Spustenie všetkých analýz paralelne
        results = await asyncio.gather(
            *[analyze_source(url) for url in urls]
        )

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

Platí však jedno upozornenie: v predvolenom nastavení gather propaguje prvú encountered výnimku a preruší celú sadu. Ak analyzuješ štyridsať externých zdrojov, stačí, aby bol jeden offline, a stratíš výsledky ostatných tridsiatich deviatich. Parameter return_exceptions=True zmení toto správanie: chyby sa vrátia ako bežné hodnoty a je na tebe, aby si ich vytriedil.

@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, urls: list) -> dict:
        # return_exceptions=True zabráni 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 pracovný tok vráti čiastočný výsledok sprevádzaný mierou úspešnosti, čo umožňuje downstream procesom rozhodnúť, či je kvalita dostatočná, alebo či je potrebné opakovanie.

Rozhodovanie v pracovnom toku

Zložité vetvenie nielenže je povolené, ale často je hlavným dôvodom používania pracovných tokov, za predpokladu, že podmienky vychádzajú z výsledkov aktivít. Prípad moderovania obsahu toto kaskádové logické konanie dobre ilustruje: automatické rozhodnutie, keď je model vysoko presvedčený, druhý názor pri strednej dôvere a eskalácia na človeka v prípade nezhody alebo nízkej dôvery.

@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ôvera: automatické rozhodnutie
            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:
            # Stredná dôvera: druhá analýza s iným modelom
            second_analysis = await analyze_content_model_b(content["text"])

            if analysis["category"] == second_analysis["category"]:
                # Oba modely súhlasia
                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:
                # Nezhoda: eskalácia na človeka
                await escalate_moderation(content["id"], analysis, second_analysis)
                return {"decision": "pending", "method": "human_escalation"}

        else:
            # Nízka dôvera: priama eskalácia
            await escalate_moderation(content["id"], analysis, None)
            return {"decision": "pending", "method": "human_escalation"}

Všimni si pole method vrátené v každom bode ukončenia: umožňuje ti spätne merať, aká časť obsahu bola spracovaná bez zásahu človeka, a podľa toho upravovať prahové hodnoty.

Fan-out / Fan-in

Posledný vzor kombinuje predchádzajúce: rozdelí prácu paralelne a následne agreguje výsledky na jednom mieste. Tu sa dokument simultánne prekladá do troch jazykov, každý preklad sa analyzuje paralelne a všetko konverguje do súhrnu.

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

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

        # Fan-in: agregácia výsledkov
        summary = await aggregate_analyses(list(analyses))

        return summary

Dve vlny paralelizmu sú po sebe idúce, pretože druhá závisí od výsledkov prvej. V striktnej sekvencii by tento pracovný tok vyžadoval sedem reťazených volaní; tu stojí len tri kroky orchestrácie.

Zhrnutie: rozdeľ zložité pracovné toky na opätovne použiteľné podpracovné toky, paralelizuj vždy, keď sú aktivity nezávislé, povoľ return_exceptions=True, keď sú čiastočné zlyhania prípustné, maj vzor pokračovania v zálohe pre veľmi dlhé spracovateľské úlohy a vždy sa uisti, že tvoje vetvenie sa spolieha na výsledky aktivít, nie na nedeterministické hodnoty.

Kľúčové poznatky

  • Pracovný tok môže spustiť iné pracovné toky prostredníctvom aktivity, ktorá volá SDK
  • Vzor pokračovania umožňuje spracovať neobmedzený počet položiek v postupných dávkach
  • asyncio.gather ti umožňuje spúšťať aktivity paralelne na zníženie celkového času
  • Zložité podmienené vetvenie je podporované, pokiaľ závisí od výsledkov aktivít
  • Vzor fan-out / fan-in rozdeľuje prácu a následne agreguje výsledky