Zaawansowane wzorce
Na tej stronie
Zaktualizowano 3 listopada 2026: Podprzepływ wcześniej zwracał
execution.output, co zostało usunięte w SDKmistralaiw wersji 3.7.0. Wynik jest teraz odczytywany zresult, przy użyciuwait_for_result=True, aby poczekać na zakończenie.
Poza liniowymi przepływami pracy
Do tej pory omawialiśmy przepływy pracy wykonujące czynności sekwencyjnie. W praktyce rzeczywiste przypadki użycia wymagają bardziej zaawansowanych wzorców: łączenia przepływów w łańcuchy, uruchamiania czynności równolegle lub podejmowania złożonych decyzji warunkowych. Te cztery wzorce – łańcuchowanie, kontynuacja, równoległość oraz fan-out/fan-in – pokrywają niemal każdą architekturę, jaką będziesz musiał zbudować.
Łańcuchowanie przepływów pracy
Przepływ pracy może uruchomić inny przepływ pracy. Możliwość ta służy dwóm odrębnym celom: rozbiciu złożonej logiki na wielokrotnego użytku podprzepływy oraz obejściu limitu 51 200 zdarzeń na wykonanie, ponieważ każdy podrzędny przepływ pracy otrzymuje własny budżet. Mechanizm ten opiera się na czynności (activity), będącej jedynym miejscem, gdzie SDK może legalnie wykonać wywołanie sieciowe.
import mistralai.workflows as workflows
from mistralai.client import Mistral
@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
"""Uruchamia podrzędny przepływ pracy i czeka na jego wynik."""
client = Mistral()
execution = await client.workflows.execute_workflow_async(
workflow_identifier=workflow_name,
input=input_data,
wait_for_result=True, # czekaj na wynik podrzędnego przepływu pracy
)
return execution.result
@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
@workflows.workflow.entrypoint
async def run(self, params: dict) -> dict:
# Krok 1: Zbieranie danych (dedykowany podprzepływ)
data = await launch_sub_workflow(
"data_collection",
{"sources": params["sources"]}
)
# Krok 2: Analiza (dedykowany podprzepływ)
analysis = await launch_sub_workflow(
"content_analysis",
{"data": data}
)
# Krok 3: Generowanie raportu (dedykowany podprzepływ)
report = await launch_sub_workflow(
"report_generation",
{"analysis": analysis, "format": params["format"]}
)
return report
Korzyść wykracza poza zwykłą czytelność: data_collection staje się samodzielnym przepływem pracy, możliwym do przetestowania w izolacji i wielokrotnego użytku przez inne potoki, z własnymi limitami czasu i politykami ponawiania prób.
Ten sam mechanizm, zastosowany do przepływu pracy wywołującego samego siebie, tworzy wzorzec kontynuacji. Zamiast przetwarzać sto tysięcy elementów w jednym wykonaniu – czego zabrania limit zdarzeń – przepływ pracy przetwarza partię i deleguje resztę do nowej instancji.
@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
# Pobierz bieżącą partię
batch = await retrieve_batch(offset, batch_size)
if not batch["items"]:
# Wszystkie partie przetworzone
return {"status": "completed", "total_processed": offset}
# Przetwórz bieżącą partię
await process_batch(batch["items"])
# Uruchom następną partię poprzez nowy przepływ pracy
next_batch = await launch_sub_workflow(
"batch_processing",
{"offset": offset + batch_size}
)
return next_batch
Każde nowe wykonanie zaczyna się z czystym dziennikiem. Liczba przetwarzalnych elementów staje się nieograniczona, a warunkiem zatrzymania jest po prostu pusta partia.
Równoległość z asyncio.gather
Gdy wiele czynności jest od siebie niezależnych, nie ma powodu, by uruchamiać je sekwencyjnie. asyncio.gather przesyła je do platformy jednocześnie, a całkowity czas zbliża się do czasu najwolniejszej czynności, a nie sumy wszystkich.
import asyncio
import mistralai.workflows as workflows
@workflows.activity()
async def analyze_source(url: str) -> dict:
"""Analizuje źródło danych."""
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:
# Uruchom wszystkie analizy równolegle
results = await asyncio.gather(
*[analyze_source(url) for url in urls]
)
return {
"source_count": len(results),
"results": list(results)
}
Należy jednak pamiętać o jednym zastrzeżeniu: domyślnie gather propaguje pierwszy napotkany wyjątek i przerywa cały zestaw. Jeśli analizujesz czterdzieści zewnętrznych źródeł, wystarczy, że jedno będzie niedostępne, aby stracić wyniki pozostałych trzydziestu dziewięciu. Parametr return_exceptions=True zmienia to zachowanie: błędy są zwracane jako zwykłe wartości, pozostawiając Tobie ich sortowanie.
@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
@workflows.workflow.entrypoint
async def run(self, urls: list) -> dict:
# return_exceptions=True zapobiega blokowaniu pozostałych przez jeden błąd
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)
}
Ten przepływ pracy zwraca wynik częściowy wraz ze wskaźnikiem sukcesu, pozwalając procesom downstream zdecydować, czy jakość jest wystarczająca, czy konieczne jest ponowienie próby.
Podejmowanie decyzji w przepływie pracy
Złożone rozgałęzienia są nie tylko dozwolone, ale często stanowią główny cel używania przepływów pracy, pod warunkiem że warunki wynikają z rezultatów czynności. Przypadek moderacji treści dobrze ilustruje tę kaskadową logikę: decyzja automatyczna, gdy model jest wysoce pewny, druga opinia przy umiarkowanym poziomie pewności oraz eskalacja do człowieka w przypadku niezgodności lub niskiej pewności.
@workflows.workflow.define(name="content_moderation")
class ContentModeration:
@workflows.workflow.entrypoint
async def run(self, content: dict) -> dict:
# Krok 1: Analiza automatyczna
analysis = await auto_analyze_content(content["text"])
if analysis["confidence_score"] > 0.95:
# Wysoka pewność: decyzja automatyczna
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:
# Umiarkowana pewność: druga analiza innym modelem
second_analysis = await analyze_content_model_b(content["text"])
if analysis["category"] == second_analysis["category"]:
# Oba modele są zgodne
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:
# Niezgodność: eskalacja do człowieka
await escalate_moderation(content["id"], analysis, second_analysis)
return {"decision": "pending", "method": "human_escalation"}
else:
# Niska pewność: bezpośrednia eskalacja
await escalate_moderation(content["id"], analysis, None)
return {"decision": "pending", "method": "human_escalation"}
Zwróć uwagę na pole method zwracane w każdym punkcie wyjścia: pozwala ono retrospektywnie zmierzyć, jaka część treści została przetworzona bez interwencji człowieka, i odpowiednio dostosować progi.
Fan-out / Fan-in
Ostatni wzorzec łączy poprzednie: rozprowadź pracę równolegle, a następnie zagreguj wyniki w jednym punkcie. Tutaj dokument jest tłumaczony jednocześnie na trzy języki, każde tłumaczenie jest analizowane równolegle, a wszystko zbiega się w podsumowaniu.
@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
@workflows.workflow.entrypoint
async def run(self, document: dict) -> dict:
# Fan-out: tłumacz równolegle na 3 języki
translations = await asyncio.gather(
translate(document["text"], "en"),
translate(document["text"], "de"),
translate(document["text"], "es")
)
# Fan-out: analizuj każde tłumaczenie równolegle
analyses = await asyncio.gather(
*[analyze_sentiment(trad["translated_text"]) for trad in translations]
)
# Fan-in: agreguj wyniki
summary = await aggregate_analyses(list(analyses))
return summary
Dwie fale równoległości następują po sobie, ponieważ druga zależy od wyników pierwszej. W ścisłej sekwencji ten przepływ pracy wymagałby siedmiu połączonych wywołań; tutaj kosztuje to tylko trzy kroki orkiestracji.
Podsumowując: rozbijaj złożone przepływy pracy na wielokrotnego użytku podprzepływy, równoleglizuj whenever czynności są niezależne, włącz return_exceptions=True, gdy częściowe awarie są akceptowalne, miej w rezerwie kontynuację dla bardzo długich zadań przetwarzania i zawsze upewniaj się, że Twoje rozgałęzienia opierają się na wynikach czynności, a nie na wartościach niedeterministycznych.
Kluczowe wnioski
- Przepływ pracy może uruchamiać inne przepływy pracy poprzez czynność wywołującą SDK
- Wzorzec kontynuacji pozwala przetwarzać nieograniczoną liczbę elementów w kolejnych partiach
asyncio.gatherpozwala uruchamiać czynności równolegle, aby skrócić całkowity czas- Złożone rozgałęzienia warunkowe są obsługiwane, o ile zależą od wyników czynności
- Wzorzec fan-out / fan-in rozprowadza pracę, a następnie agreguje wyniki