Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Täiustatud mustrid

Õppetund 11 / 14 Värskendatud 3. november 2026 Edasijõudnutele
Sellel lehel
  1. Lineaarsetest voogudest kaugemale
  2. Voogude aheldamine
  3. Paralleelimine asyncio.gather abil
  4. Otsuste tegemine voos
  5. Fan-out / Fan-in
  6. Peamised punktid

Uuendatud 3. novembril 2026: Alamvoogude varem tagastatud execution.output puudub mistralai SDK versioonis 3.7.0. Tulemust loetakse nüüd väljalt result, kasutades lõpuleviimise ootamiseks parameetrit wait_for_result=True.

Lineaarsetest voogudest kaugemale

Seni oleme vaadelnud vooge, mis käivitavad tegevusi järjestikku. Praktikas nõuavad reaalsed kasutusjuhtumid keerukamaid mustreid: voogude aheldamine, tegevuste paralleelne käivitamine või keerukate tingimuslike otsuste tegemine. Need neli mustrit – aheldamine, jätkamine, paralleelsus ja fan-out/fan-in – katavad peaaegu kogu arhitektuuri, mida sul ehitamiseks vaja läheb.

Voogude aheldamine

Voog võib käivitada teise voo. See võimalus teenib kahte erinevat eesmärki: keeruka loogika lagundamine uuestikasutatavateks alamvoogudeks ja 51 200 sündmuse piirangu ületamine ühe täitmise kohta, kuna iga lapsvoog saab oma eelarve. Mehhanism tugineb tegevusele, mis on ainus koht, kus SDK saab seaduslikult võrgukutsu teha.

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

@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
    """Käivitab lapsvoo ja ootab selle tulemust."""
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier=workflow_name,
        input=input_data,
        wait_for_result=True,  # oota lapsvoo tulemust
    )
    return execution.result

@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        # 1. samm: Andmete kogumine (spetsiaalne alamvoog)
        data = await launch_sub_workflow(
            "data_collection",
            {"sources": params["sources"]}
        )

        # 2. samm: Analüüs (spetsiaalne alamvoog)
        analysis = await launch_sub_workflow(
            "content_analysis",
            {"data": data}
        )

        # 3. samm: Aruande genereerimine (spetsiaalne alamvoog)
        report = await launch_sub_workflow(
            "report_generation",
            {"analysis": analysis, "format": params["format"]}
        )

        return report

Kasu ei seisne ainult loetavuses: data_collection muutub iseseisvaks vooks, mida saab testida isoleeritult ja mida saavad kasutada teised torustikud, omades oma aegumisi ja uuestiproovimise poliitikaid.

Sama mehhanismi rakendamine voole, mis kutsub iseennast, loob jätkamise mustri. Ühe täitmise käigus saja tuhande elemendi töötlemise asemel – mida sündmuste piirang keelab – töötleb voog partii ja delegeerib ülejäänu uuele eksemplarile.

@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

        # Haara praegune partii
        batch = await retrieve_batch(offset, batch_size)

        if not batch["items"]:
            # Kõik partiid on töödeldud
            return {"status": "completed", "total_processed": offset}

        # Töötle praegune partii
        await process_batch(batch["items"])

        # Käivita järgmine partii uue voo kaudu
        next_batch = await launch_sub_workflow(
            "batch_processing",
            {"offset": offset + batch_size}
        )

        return next_batch

Iga uus täitmine algab puhta ajakirjaga. Töödeldavate elementide arv muutub piiramatuks, kusjuures peatumistingimuseks on lihtsalt tühi partii.

Paralleelimine asyncio.gather abil

Kui mitu tegevust on üksteisest sõltumatud, pole mõtet neid järjestikku käivitada. asyncio.gather esitab need platvormile samaaegselt ja koguaeg läheneb aeglaseima tegevuse ajale, mitte kõigi tegevuste ajade summale.

import asyncio
import mistralai.workflows as workflows

@workflows.activity()
async def analyze_source(url: str) -> dict:
    """Analüüsib andmeallikat."""
    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:
        # Käivita kõik analüüsid paralleelselt
        results = await asyncio.gather(
            *[analyze_source(url) for url in urls]
        )

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

Siin kehtib aga üks hoiatus: vaikimisi levitab gather esimest tekkinud erindit ja katkestab kogu komplekti. Kui analüüsid neljakümmet välist allikat, põhjustab juba ühe offline olek teiste kolmekümne üheksa kaotuse. Parameeter return_exceptions=True muudab seda käitumist: vead tagastatakse tavaliste väärtustena, jättes sinu otsustada, kuidas nendega toime tulla.

@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, urls: list) -> dict:
        # return_exceptions=True takistab ühel veal teisi blokeerimast
        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)
        }

See voog tagastab osalise tulemuse koos õnnestumise määraga, võimaldades järgnevatel protsessidel otsustada, kas kvaliteet on piisav või on vaja uuesti proovida.

Otsuste tegemine voos

Keerukas harudeks jagunemine pole mitte ainult lubatud, vaid on sageli voogude kasutamise peamine eesmärk, eeldusel, et tingimused tulenevad tegevuste tulemustest. Sisumoderatsiooni juhtum illustreerib seda kaskaadset loogikat hästi: automaatne otsus, kui mudel on väga kindel, teine arvamus mõõduka kindluse korral ja inimesele eskaleerimine lahkarvamuse või madala kindluse korral.

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

        if analysis["confidence_score"] > 0.95:
            # Kõrge kindlus: automaatne otsus
            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:
            # Mõõdukas kindlus: teine analüüs teise mudeliga
            second_analysis = await analyze_content_model_b(content["text"])

            if analysis["category"] == second_analysis["category"]:
                # Mõlemad mudelid on sama meelt
                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:
                # Lahkarvamus: eskaleerimine inimesele
                await escalate_moderation(content["id"], analysis, second_analysis)
                return {"decision": "pending", "method": "human_escalation"}

        else:
            # Madal kindlus: otsene eskaleerimine
            await escalate_moderation(content["id"], analysis, None)
            return {"decision": "pending", "method": "human_escalation"}

Pane tähele iga väljumispunktis tagastatud välja method: see võimaldab sul tagantjärele mõõta, milline osa sisust töödeldi ilma inimese sekkumiseta, ja seega vastavalt lävendeid kohandada.

Fan-out / Fan-in

Viimane muster ühendab eelmisi: jaga töö paralleelselt ja seejärel koonda tulemused ühes punktis. Siin tõlgitakse dokument samaaegselt kolme keelde, iga tõlget analüüsitakse paralleelselt ja kõik koondub kokkuvõtteks.

@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, document: dict) -> dict:
        # Fan-out: tõlgi paralleelselt 3 keelde
        translations = await asyncio.gather(
            translate(document["text"], "en"),
            translate(document["text"], "de"),
            translate(document["text"], "es")
        )

        # Fan-out: analüüsi iga tõlget paralleelselt
        analyses = await asyncio.gather(
            *[analyze_sentiment(trad["translated_text"]) for trad in translations]
        )

        # Fan-in: koonda tulemused
        summary = await aggregate_analyses(list(analyses))

        return summary

Kaks paralleelsuse lainet on järjestikused, kuna teine sõltub esimese tulemustest. Rangelt järjestikuses vormis nõuaks see voog seitset aheldatud kutset; siin maksab see vaid kolm orkestreerimissammu.

Kokkuvõtteks: lagunda keerukad voogudeks uuestikasutatavateks alamvoogudeks, paralleeli alati, kui tegevused on sõltumatud, lülita sisse return_exceptions=True, kui osalised ebaõnnestumised on talutavad, hoia jätkamine varuks väga pikkade töötlemistööde jaoks ja veendu alati, et sinu harudeks jagunemine tugineb tegevuste tulemustele, mitte mittedeterministlikele väärtustele.

Peamised punktid

  • Voog saab käivitada teisi vooge tegevuse kaudu, mis kutsub SDK-d
  • Jätkamise muster võimaldab töödelda piiramatut hulka elemente järjestikustes partiides
  • asyncio.gather võimaldab käivitada tegevusi paralleelselt, et vähendada koguaega
  • Keerukas tingimuslik harudeks jagunemine on toetatud, kui see sõltub tegevuste tulemustest
  • Fan-out / fan-in muster jagab töö ja koondab seejärel tulemused