Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Mudelli Avvanzati

Lezzjoni 11 / 14 Aġġornat 3 ta’ Novembru 2026 Avvanzat
F'din il-paġna
  1. Lil hinn mill-Workflows Lineari
  2. Tgħaqqid tal-Workflows (Chaining)
  3. Parallelizzazzjoni b’asyncio.gather
  4. Teħid ta’ Deċiżjonijiet fil-Workflow
  5. Fan-out / Fan-in
  6. Punti Ewlenin

Aġġornat fit-3 ta’ Novembru, 2026: Is-sottoworkflow qabel kien jirritorna execution.output, li nieqes mill-SDK mistralai 3.7.0. Ir-riżultat issa jinqara minn result, bl-użu ta’ wait_for_result=True biex tistenna t-tlestija.

Lil hinn mill-Workflows Lineari

S’issa, rajna workflows li jesegwixxu attivitajiet b’mod sekwenzjali. Fil-prattika, każijiet ta’ użu fid-dinja reali jeħtieġu mudelli aktar sofistikati: tgħaqqid ta’ workflows, tħaddim ta’ attivitajiet paralleli, jew teħid ta’ deċiżjonijiet kondizzjonali kumplessi. Dawn l-erba’ mudelli—chaining, continuation, parallelism, u fan-out/fan-in—jkopru kważi kull arkitettura li se jkollok bżonn tibni.

Tgħaqqid tal-Workflows (Chaining)

Workflow jista’ jniedi workflow ieħor. Din il-kapaċità sservi żewġ għanijiet distinti: tqassim ta’ loġika kumplessa f’sottoworkflows li jistgħu jerġgħu jintużaw, u evitar tal-limitu ta’ 51,200 avveniment għal kull eżekuzzjoni, peress li kull workflow iben jikseb baġit tiegħu stess. Il-mekkaniżmu jiddependi fuq attività, l-uniku post fejn l-SDK jista’ legalment jagħmel sejħa tan-network.

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

@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
    """Jniedi workflow iben u jistenna r-riżultat tiegħu."""
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier=workflow_name,
        input=input_data,
        wait_for_result=True,  # istenna r-riżultat tal-workflow iben
    )
    return execution.result

@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        # Pass 1: Ġbir tad-data (sottoworkflow dedikat)
        data = await launch_sub_workflow(
            "data_collection",
            {"sources": params["sources"]}
        )

        # Pass 2: Analiżi (sottoworkflow dedikat)
        analysis = await launch_sub_workflow(
            "content_analysis",
            {"data": data}
        )

        # Pass 3: Ġenerazzjoni tar-rapport (sottoworkflow dedikat)
        report = await launch_sub_workflow(
            "report_generation",
            {"analysis": analysis, "format": params["format"]}
        )

        return report

Il-benefiċċju jmur lil hinn minn sempliċi leġibbiltà: data_collection isir workflow awtonomu, li jista’ jiġi ttestjat f’iżolament u użat mill-ġdid minn pipelines oħra, bil-politiki ta’ timeout u retry tiegħu stess.

L-istess mekkaniżmu, applikat għal workflow li jsejjaħ lilu nnifsu, joħloq il-mudell ta’ continuation. Minflok ma tipproċessa mitt elf oġġett f’eżekuzzjoni waħda—li l-kapp tal-avvenimenti jipprojbixxi—il-workflow jipproċessa lott u jiddelega l-bqija għal istanza ġdida.

@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

        # Irkupra l-lott attwali
        batch = await retrieve_batch(offset, batch_size)

        if not batch["items"]:
            # Il-lottijiet kollha ġew ipproċessati
            return {"status": "completed", "total_processed": offset}

        # Ipproċessa l-lott attwali
        await process_batch(batch["items"])

        # Neddi l-lott li jmiss permezz ta' workflow ġdid
        next_batch = await launch_sub_workflow(
            "batch_processing",
            {"offset": offset + batch_size}
        )

        return next_batch

Kull eżekuzzjoni ġdida tibda b’ġurnal nadif. In-numru ta’ oġġetti li jistgħu jiġu pproċessati jsir illimitat, bil-kundizzjoni ta’ waqfien li tkun sempliċiment lott vojt.

Parallelizzazzjoni b’asyncio.gather

Meta attivitajiet multipli huma indipendenti minn xulxin, m’hemm l-ebda raġuni biex tħaddimhom b’mod sekwenzjali. asyncio.gather jissottomettihom lill-pjattaforma simultanjament, u l-ħin totali jersaq lejn dak tal-aktar attività bil-mod minflok is-somma ta’ kollha kemm huma.

import asyncio
import mistralai.workflows as workflows

@workflows.activity()
async def analyze_source(url: str) -> dict:
    """Janalizza sors tad-data."""
    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:
        # Neddi l-analiżijiet kollha b'mod parallel
        results = await asyncio.gather(
            *[analyze_source(url) for url in urls]
        )

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

Madankollu, hemm avvertenza waħda: b’mod default, gather jippropaga l-ewwel eċċezzjoni li tiltaqa’ magħha u jwaqqaf is-sett kollu. Jekk qed tanalizza erbgħin sors estern, sors wieħed biss li ma jkunx online jikkawżalek titlef l-oħrajn disgħa u tletin. Il-parametru return_exceptions=True ibiddel dan l-imġiba: l-iżbalji jiġu rritornati bħala valuri ordinarji, u jħalluk issortjahom int.

@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, urls: list) -> dict:
        # return_exceptions=True jipprevjeni li żball wieħed jimblokka l-oħrajn
        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)
        }

Dan il-workflow jirritorna riżultat parzjali akkumpanjat minn rata ta’ suċċess, li jippermetti lill-proċessi downstream jiddeċiedu jekk il-kwalità hijiex suffiċjenti jew jekk hemmx bżonn ta’ retry.

Teħid ta’ Deċiżjonijiet fil-Workflow

Ferghat kumplessi (branching) mhux biss huma permessi iżda spiss huma l-punt ewlieni tal-użu tal-workflows, sakemm il-kundizzjonijiet jiġu mir-riżultati tal-attività. Il-każ tal-moderazzjoni tal-kontenut juri din il-loġika kaskata sewwa: deċiżjoni awtomatika meta l-mudell ikun kunfidenti ħafna, it-tieni opinjoni meta l-kunfidenza tkun moderata, u eskalazzjoni umana f’każ ta’ nuqqas ta’ qbil jew kunfidenza baxxa.

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

        if analysis["confidence_score"] > 0.95:
            # Kunfidenza għolja: deċiżjoni awtomatika
            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:
            # Kunfidenza moderata: it-tieni analiżi b'mudell differenti
            second_analysis = await analyze_content_model_b(content["text"])

            if analysis["category"] == second_analysis["category"]:
                # Iż-żewġ mudelli jaqblu
                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:
                # Nuqqas ta' qbil: eskalazzjoni umana
                await escalate_moderation(content["id"], analysis, second_analysis)
                return {"decision": "pending", "method": "human_escalation"}

        else:
            # Kunfidenza baxxa: eskalazzjoni diretta
            await escalate_moderation(content["id"], analysis, None)
            return {"decision": "pending", "method": "human_escalation"}

Innota l-qasam method irritornat f’kull punt ta’ ħruġ: dan jippermettilek tkejjel retrospettivament liema proporzjon ta’ kontenut ġie pproċessat mingħajr intervent uman, u b’hekk taġġusta l-limiti (thresholds) skont dan.

Fan-out / Fan-in

L-aħħar mudell jgħaqqad dawk ta’ qabel: ixerred ix-xogħol b’mod parallel, imbagħad jaggrega r-riżultati f’punt wieħed. Hawnhekk, dokument jiġi tradott simultanjament fi tliet lingwi, kull traduzzjoni tiġi analizzata b’mod parallel, u kollox jikkonverġi f’sommarju.

@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, document: dict) -> dict:
        # Fan-out: ittraduċi b'mod parallel fi 3 lingwi
        translations = await asyncio.gather(
            translate(document["text"], "en"),
            translate(document["text"], "de"),
            translate(document["text"], "es")
        )

        # Fan-out: analizza kull traduzzjoni b'mod parallel
        analyses = await asyncio.gather(
            *[analyze_sentiment(trad["translated_text"]) for trad in translations]
        )

        # Fan-in: aggrega r-riżultati
        summary = await aggregate_analyses(list(analyses))

        return summary

Iż-żewġ mewġ ta’ parallelism huma suċċessivi għax it-tieni tiddependi mir-riżultati tal-ewwel. F’sekwenza stretta, dan il-workflow ikun jeħtieġ seba’ sejħiet imqabbda; hawnhekk, jiswifik biss tliet passi ta’ orkestrazzjoni.

Fil-qosor, qassam workflows kumplessi f’sottoworkflows li jistgħu jerġgħu jintużaw, parallellizza kull meta l-attivtjiet ikunu indipendenti, ippermetti return_exceptions=True meta fallimenti parzjali jkunu tollerabbli, żomm il-continuation bħala riżerva għal xogħlijiet ta’ pproċessar twil ħafna, u dejjem kun żgur li l-fergħat (branching) tiegħek jiddependu fuq ir-riżultati tal-attività minflok valuri mhux deterministiċi.

Punti Ewlenin

  • Workflow jista’ jniedi workflows oħra permezz ta’ attività li ssejjaħ lill-SDK
  • Il-mudell ta’ continuation jippermetti l-ipproċessar ta’ numru illimitat ta’ oġġetti f’lottijiet suċċessivi
  • asyncio.gather jippermettilek tħaddem attivitajiet b’mod parallel biex tnaqqas il-ħin totali
  • Ferghat kondizzjonali kumplessi huma appoġġjati sakemm jiddependu fuq ir-riżultati tal-attività
  • Il-mudell fan-out / fan-in ixerred ix-xogħol u mbagħad jaggrega r-riżultati