Mudelli Avvanzati
F'din il-paġna
Aġġornat fit-3 ta’ Novembru, 2026: Is-sottoworkflow qabel kien jirritorna
execution.output, li nieqes mill-SDKmistralai3.7.0. Ir-riżultat issa jinqara minnresult, bl-użu ta’wait_for_result=Truebiex 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.gatherjippermettilek 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