Napredni obrasci
Na ovoj stranici
Ažurirano 3. studenog 2026.: Podradni tijek (sub-workflow) prethodno je vraćao
execution.output, što nedostaje u SDK-umistralaiverzije 3.7.0. Rezultat se sada čita izresult, koristećiwait_for_result=Truekako bi se pričekalo dovršetak.
Izvan linearnih radnih tijekova
Do sada smo promatrali radne tijekove koji izvršavaju aktivnosti sekvencijalno. U praksi stvarni slučajevi upotrebe zahtijevaju sofisticiranije obrasce: lančanje radnih tijekova, paralelno pokretanje aktivnosti ili donošenje složenih uvjetnih odluka. Ova četiri obrasca – lančanje, nastavak (continuation), paralelizam i fan-out/fan-in – pokrivaju gotovo svaku arhitekturu koju ćeš trebati izgraditi.
Lančanje radnih tijekova
Radni tijek može pokrenuti drugi radni tijek. Ta mogućnost služi dvama različitim ciljevima: razbijanju složene logike na ponovno upotrebljive podradne tijekove i zaobilaženju ograničenja od 51.200 događaja po izvršenju, budući da svaki podređeni radni tijek dobiva vlastiti budžet. Mehanizam se oslanja na aktivnost, jedino mjesto gdje SDK legitimno može izvršiti mrežni poziv.
import mistralai.workflows as workflows
from mistralai.client import Mistral
@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
"""Pokreće podređeni radni tijek i čeka njegov rezultat."""
client = Mistral()
execution = await client.workflows.execute_workflow_async(
workflow_identifier=workflow_name,
input=input_data,
wait_for_result=True, # čekaj rezultat podređenog radnog tijeka
)
return execution.result
@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
# Korak 1: Prikupljanje podataka (namjenski podradni tijek)
data = await launch_sub_workflow(
"data_collection",
{"sources": params["sources"]}
)
# Korak 2: Analiza (namjenski podradni tijek)
analysis = await launch_sub_workflow(
"content_analysis",
{"data": data}
)
# Korak 3: Generiranje izvješća (namjenski podradni tijek)
report = await launch_sub_workflow(
"report_generation",
{"analysis": analysis, "format": params["format"]}
)
return report
Prednost nadilazi jednostavnu čitljivost: data_collection postaje samostalni radni tijek, testabilan u izolaciji i ponovno upotrebljiv od strane drugih pipelineova, s vlastitim vremenskim ograničenjima i pravilima ponovnog pokušaja.
Isti mehanizam, primijenjen na radni tijek koji poziva sam sebe, stvara obrazac nastavka (continuation). Umjesto obrade sto tisuća stavki u jednom izvršenju – što ograničenje događaja zabranjuje – radni tijek obrađuje šaržu (batch) i delegira ostatak novoj instanci.
@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
# Dohvati trenutnu šaržu
batch = await retrieve_batch(offset, batch_size)
if not batch["items"]:
# Sve šarže obrađene
return {"status": "completed", "total_processed": offset}
# Obradi trenutnu šaržu
await process_batch(batch["items"])
# Pokreni sljedeću šaržu putem novog radnog tijeka
next_batch = await launch_sub_workflow(
"batch_processing",
{"offset": offset + batch_size}
)
return next_batch
Svako novo izvršenje započinje s čistim dnevnikom (journal). Broj stavki koje se mogu obraditi postaje neograničen, pri čemu je uvjet zaustavljanja jednostavno prazna šarža.
Paralelizacija s asyncio.gather
Kada su višestruke aktivnosti međusobno neovisne, nema razloga pokretati ih sekvencijalno. asyncio.gather šalje ih platformi istovremeno, a ukupno vrijeme približava se vremenu najsporije aktivnosti, a ne zbroju svih njih.
import asyncio
import mistralai.workflows as workflows
@workflows.activity()
async def analyze_source(url: str) -> dict:
"""Analizira izvor podataka."""
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:
# Pokreni sve analize paralelno
results = await asyncio.gather(
*[analyze_source(url) for url in urls]
)
return {
"source_count": len(results),
"results": list(results)
}
Postoji jedna napomena: prema zadanim postavkama, gather propagira prvu encountered iznimku i prekida cijeli skup. Ako analiziraš četrdeset vanjskih izvora, samo jedan izvan mreže uzrokuje gubitak preostalih trideset i devet. Parametar return_exceptions=True mijenja to ponašanje: pogreške se vraćaju kao obične vrijednosti, ostavljajući tebi da ih razvrstaš.
@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# return_exceptions=True sprječava da jedna pogreška blokira ostale
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)
}
Ovaj radni tijek vraća djelomični rezultat popraćen stopom uspješnosti, omogućujući nizvodnim procesima da odluče je li kvaliteta dovoljna ili je potreban ponovni pokušaj.
Donošenje odluka u radnom tijeku
Složeno grananje nije samo dopušteno, već je često i glavna svrha korištenja radnih tijekova, pod uvjetom da uvjeti proizlaze iz rezultata aktivnosti. Slučaj moderacije sadržaja dobro ilustrira ovu kaskadnu logiku: automatska odluka kada je model vrlo siguran, drugo mišljenje kada je sigurnost umjerena, i eskalacija na čovjeka u slučaju neslaganja ili niske sigurnosti.
@workflows.workflow.define(name="content_moderation")
class ContentModeration:
@workflows.workflow.entrypoint
async def run(self, content: dict) -> dict:
# Korak 1: Automatska analiza
analysis = await auto_analyze_content(content["text"])
if analysis["confidence_score"] > 0.95:
# Visoka sigurnost: automatska odluka
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:
# Umjerena sigurnost: druga analiza s drugačijim modelom
second_analysis = await analyze_content_model_b(content["text"])
if analysis["category"] == second_analysis["category"]:
# Oba modela se slažu
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:
# Neslaganje: eskalacija na čovjeka
await escalate_moderation(content["id"], analysis, second_analysis)
return {"decision": "pending", "method": "human_escalation"}
else:
# Niska sigurnost: izravna eskalacija
await escalate_moderation(content["id"], analysis, None)
return {"decision": "pending", "method": "human_escalation"}
Primijeti polje method vraćeno na svakoj izlaznoj točki: ono ti omogućuje da retrospektivno izmjeriš koji je udio sadržaja obrađen bez ljudske intervencije i sukladno tome prilagodiš pragove.
Fan-out / Fan-in
Završni obrazac kombinira prethodne: distribuiraj posao paralelno, a zatim agregiraj rezultate na jednoj točki. Ovdje se dokument istovremeno prevodi na tri jezika, svaki prijevod se analizira paralelno, a sve konvergira u sažetak.
@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
@workflows.workflow.entrypoint
async def run(self, document: dict) -> dict:
# Fan-out: paralelno prevođenje na 3 jezika
translations = await asyncio.gather(
translate(document["text"], "en"),
translate(document["text"], "de"),
translate(document["text"], "es")
)
# Fan-out: paralelna analiza svakog prijevoda
analyses = await asyncio.gather(
*[analyze_sentiment(trad["translated_text"]) for trad in translations]
)
# Fan-in: agregacija rezultata
summary = await aggregate_analyses(list(analyses))
return summary
Dva vala paralelizma su uzastopna jer drugi ovisi o rezultatima prvog. U strogoj sekvenci, ovaj radni tijek zahtijevao bi sedam lančanih poziva; ovdje košta samo tri koraka orkestracije.
Ukratko, razbij složene radne tijekove na ponovno upotrebljive podradne tijekove, paraleliziraj kad god su aktivnosti neovisne, omogući return_exceptions=True kada su djelomični neuspjesi prihvatljivi, zadrži nastavak (continuation) u rezervi za vrlo dugačke zadatke obrade i uvijek osiguraj da se tvoje grananje oslanja na rezultate aktivnosti, a ne na nedeterminističke vrijednosti.
Ključne točke
- Radni tijek može pokrenuti druge radne tijekove putem aktivnosti koja poziva SDK
- Obrazac nastavka (continuation) omogućuje obradu neograničenog broja stavki u uzastopnim šaržama
asyncio.gatheromogućuje pokretanje aktivnosti paralelno kako bi se smanjilo ukupno vrijeme- Složeno uvjetno grananje podržano je sve dok ovisi o rezultatima aktivnosti
- Obrazac fan-out / fan-in distribuira posao, a zatim agregira rezultate