Przejdź do głównej treści
Polski— Wybierz język
Menu

Zaawansowane wzorce

Lekcja 11 z 14 Zaktualizowano 3 listopada 2026 Zaawansowany
Na tej stronie
  1. Poza liniowymi przepływami pracy
  2. Łańcuchowanie przepływów pracy
  3. Równoległość z asyncio.gather
  4. Podejmowanie decyzji w przepływie pracy
  5. Fan-out / Fan-in
  6. Kluczowe wnioski

Zaktualizowano 3 listopada 2026: Podprzepływ wcześniej zwracał execution.output, co zostało usunięte w SDK mistralai w wersji 3.7.0. Wynik jest teraz odczytywany z result, przy użyciu wait_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.gather pozwala 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