Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Haladó minták

11. lecke 14 közül Frissítve 2026. november 3. Haladó
Ezen az oldalon
  1. Túl az lineáris munkafolyamatokon
  2. Munkafolyamatok láncolása
  3. Párhuzamosítás az asyncio.gather segítségével
  4. Döntéshozatal a munkafolyamatban
  5. Szétosztás / Összegzés (Fan-out / Fan-in)
  6. Főbb megállapítások

Frissítve: 2026. november 3.: Az al-munkafolyamat korábban az execution.output értéket adta vissza, amely hiányzik a mistralai SDK 3.7.0 verziójából. Az eredményt most a result mezőből olvassuk ki, a wait_for_result=True paraméter használatával várva a befejezésre.

Túl az lineáris munkafolyamatokon

Eddig olyan munkafolyamatokat vizsgáltunk, amelyek tevékenységeket hajtanak végre szekvenciálisan. A gyakorlatban a valós esetek ennél összetettebb mintákat igényelnek: munkafolyamatok láncolása, tevékenységek párhuzamos futtatása vagy komplex feltételes döntések meghozatala. Ez a négy minta – a láncolás, a folytatás, a párhuzamosítás és a szétosztás/összegzés (fan-out/fan-in) – lefedi szinte minden olyan architektúrát, amelyet valaha is fel kell építened.

Munkafolyamatok láncolása

Egy munkafolyamat képes másik munkafolyamatot elindítani. Ez a képesség két különböző célt szolgál: az összetett logika újrafelhasználható al-munkafolyamatokra bontását, valamint az egyes végrehajtásokra vonatkozó 51 200 eseményes korlát megkerülését, mivel minden gyermek munkafolyamat saját kerettel rendelkezik. A mechanizmus egy tevékenységre támaszkodik, mivel ez az egyetlen hely, ahol az SDK jogosult hálózati hívást kezdeményezni.

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

@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
    """Elindít egy gyermek munkafolyamatot, és megvárja az eredményét."""
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier=workflow_name,
        input=input_data,
        wait_for_result=True,  # megvárja a gyermek munkafolyamat eredményét
    )
    return execution.result

@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        # 1. lépés: Adatgyűjtés (dedikált al-munkafolyamat)
        data = await launch_sub_workflow(
            "data_collection",
            {"sources": params["sources"]}
        )

        # 2. lépés: Elemzés (dedikált al-munkafolyamat)
        analysis = await launch_sub_workflow(
            "content_analysis",
            {"data": data}
        )

        # 3. lépés: Jelentéskészítés (dedikált al-munkafolyamat)
        report = await launch_sub_workflow(
            "report_generation",
            {"analysis": analysis, "format": params["format"]}
        )

        return report

Az előny túlmutat az egyszerű olvashatóságon: a data_collection önálló munkafolyamattá válik, amely izoláltan tesztelhető és más folyamatok által is újrafelhasználható, saját időtúllépési és újrapróbálkozási szabályokkal.

Ugyanez a mechanizmus, ha egy olyan munkafolyamatra alkalmazzuk, amely önmagát hívja meg, létrehozza a folytatási mintát. Ahelyett, hogy százezer elemet dolgoznánk fel egyetlen végrehajtásban – amit az eseménykorlát tiltana –, a munkafolyamat feldolgoz egy köteget, majd a maradékot egy új példányra bízza.

@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

        # A jelenlegi köteg lekérése
        batch = await retrieve_batch(offset, batch_size)

        if not batch["items"]:
            # Minden köteg feldolgozva
            return {"status": "completed", "total_processed": offset}

        # A jelenlegi köteg feldolgozása
        await process_batch(batch["items"])

        # A következő köteg elindítása egy új munkafolyamaton keresztül
        next_batch = await launch_sub_workflow(
            "batch_processing",
            {"offset": offset + batch_size}
        )

        return next_batch

Minden új végrehajtás tiszta naplóval indul. A feldolgozható elemek száma így korlátlanná válik, a leállási feltétel pedig egyszerűen egy üres köteg.

Párhuzamosítás az asyncio.gather segítségével

Amikor több tevékenység független egymástól, nincs ok sorban futtatni őket. Az asyncio.gather egyszerre nyújtja be őket a platformnak, így a teljes időtartam inkább a leglassabb tevékenység idejéhez közelít, semmint az összes idejének összegéhez.

import asyncio
import mistralai.workflows as workflows

@workflows.activity()
async def analyze_source(url: str) -> dict:
    """Elemzi az adatforrást."""
    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:
        # Minden elemzés párhuzamos elindítása
        results = await asyncio.gather(
            *[analyze_source(url) for url in urls]
        )

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

Van azonban egy fontos figyelmeztetés: alapértelmezés szerint a gather továbbítja az első encountered kivételt, és megszakítja az egész csoportot. Ha negyven külső forrást elemzel, már egyetlen offline forrás is okozhatja, hogy elveszítsd a másik harminckilencet. A return_exceptions=True paraméter megváltoztatja ezt a viselkedést: a hibák rendes értékként térnek vissza, így rád marad a rendezésük.

@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, urls: list) -> dict:
        # A return_exceptions=True megakadályozza, hogy egy hiba blokkolja a többit
        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)
        }

Ez a munkafolyamat egy részleges eredményt ad vissza egy sikerességi rátával együtt, lehetővé téve a downstream folyamatok számára, hogy eldöntsék: megfelelő-e a minőség, vagy szükség van-e újrapróbálkozásra.

Döntéshozatal a munkafolyamatban

A komplex elágazások nemcsak megengedettek, hanem gyakran a munkafolyamatok használatának fő céljai, feltéve, hogy a feltételek tevékenységek eredményeiből származnak. A tartalom-moderáció esete jól illusztrálja ezt a lépcsőzetes logikát: automatikus döntés, ha a modell nagyon magabiztos; második vélemény, ha a magabiztosság közepes; és emberi eskaláció véleményeltérés vagy alacsony magabiztosság esetén.

@workflows.workflow.define(name="content_moderation")
class ContentModeration:
    @workflows.workflow.entrypoint
    async def run(self, content: dict) -> dict:
        # 1. lépés: Automatikus elemzés
        analysis = await auto_analyze_content(content["text"])

        if analysis["confidence_score"] > 0.95:
            # Magas magabiztosság: automatikus döntés
            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:
            # Közepes magabiztosság: második elemzés egy másik modellel
            second_analysis = await analyze_content_model_b(content["text"])

            if analysis["category"] == second_analysis["category"]:
                # Mindkét modell egyetért
                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:
                # Véleményeltérés: emberi eskaláció
                await escalate_moderation(content["id"], analysis, second_analysis)
                return {"decision": "pending", "method": "human_escalation"}

        else:
            # Alacsony magabiztosság: közvetlen eskaláció
            await escalate_moderation(content["id"], analysis, None)
            return {"decision": "pending", "method": "human_escalation"}

Figyeld meg a method mezőt, amely minden kilépési pontnál visszatér: ez lehetővé teszi, hogy utólag mérd, a tartalom mekkora hányadát dolgozták fel emberi beavatkozás nélkül, és ennek megfelelően állítsd be a küszöbértékeket.

Szétosztás / Összegzés (Fan-out / Fan-in)

Az utolsó minta kombinálja az előzőeket: a munka párhuzamos szétosztása, majd az eredmények egyetlen ponton történő összegzése. Itt egy dokumentumot egyszerre fordítanak le három nyelvre, minden fordítást párhuzamosan elemeznek, majd minden konvergál egy összefoglalóba.

@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, document: dict) -> dict:
        # Fan-out: párhuzamos fordítás 3 nyelvre
        translations = await asyncio.gather(
            translate(document["text"], "en"),
            translate(document["text"], "de"),
            translate(document["text"], "es")
        )

        # Fan-out: minden fordítás párhuzamos elemzése
        analyses = await asyncio.gather(
            *[analyze_sentiment(trad["translated_text"]) for trad in translations]
        )

        # Fan-in: eredmények összegzése
        summary = await aggregate_analyses(list(analyses))

        return summary

A két párhuzamosítási hullám egymást követi, mivel a második az első eredményeitől függ. Szigorú szekvenciában ez a munkafolyamat hét láncolt hívást igényelne; itt azonban csak három orchestrációs lépésbe kerül.

Összefoglalva: bontsd az összetett munkafolyamatokat újrafelhasználható al-munkafolyamatokra, párhuzamosítsd a tevékenységeket, amikor azok függetlenek, engedélyezd a return_exceptions=True opciót, ha a részleges hibák tolerálhatók, tartsd tartalékban a folytatási mintát nagyon hosszú feldolgozási feladatokhoz, és mindig győződj meg róla, hogy az elágazásaid tevékenységek eredményein alapulnak, nem pedig nem determinisztikus értékeken.

Főbb megállapítások

  • Egy munkafolyamat más munkafolyamatokat is elindíthat egy olyan tevékenységen keresztül, amely meghívja az SDK-t
  • A folytatási minta lehetővé teszi korlátlan számú elem feldolgozását egymást követő kötegekben
  • Az asyncio.gather lehetővé teszi a tevékenységek párhuzamos futtatását a teljes idő csökkentése érdekében
  • A komplex feltételes elágazások támogatottak, amennyiben azok tevékenységek eredményeitől függenek
  • A szétosztás / összegzés (fan-out / fan-in) minta szétosztja a munkát, majd összegzi az eredményeket