Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Pravidlo determinismu

Lekce 8 z 14 Aktualizováno 2. listopadu 2026 Pokročilý
Na této stránce
  1. Proč je determinismus povinný
  2. Jak to vypadá v kódu
  3. Náhrady v SDK
  4. Hranice, na kterou si musíš pamatovat
  5. Diagnostika chyby nedeterminismu
  6. Klíčové poznatky

Proč je determinismus povinný

Determinismus je nejkritičtějším omezením v pracovních postupech Mistral a přímo vyplývá z mechanismu přehrávání, který jsi se naučil dříve. Když worker obnoví přerušený pracovní postup, přehraje kód tohoto postupu od začátku a porovnává operaci po operaci to, co kód produkuje, s tím, co zaznamenal protokol historie. Dokud se obě sekvence shodují, je obnovení neviditelné. V okamžiku, kdy se rozcházejí, platforma nemá způsob, jak zjistit, kde skončila: detekuje nekonzistenci a selže pracovní postup s chybou nedeterminismu.

V praxi deterministický pracovní postup produkuje při každém spuštění se stejnými vstupy přesně stejnou sekvenci operací. Všimni si nuance: výsledky aktivit se mohou mezi jednotlivými provedeními lišit, protože pocházejí z žurnálu. Je to pořadí volání, které musí zůstat identické.

Jak to vypadá v kódu

Uvažuj pracovní postup, který odešle uživateli report na základě stavu jeho předplatného.

@workflows.workflow.define(name="deterministic_workflow")
class DeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # Pro stejný vstup vždy stejná sekvence volání
        profile = await get_profile(user_id)
        
        if profile["premium"]:
            report = await generate_full_report(user_id)
        else:
            report = await generate_basic_report(user_id)
        
        await send_email(profile["email"], report)
        return {"status": "completed"}

Tento pracovní postup je deterministický, přestože obsahuje větev. Důvod spočívá ve zdroji podmínky: profile["premium"] pochází z výsledku aktivity, tedy z žurnálu. Během přehrávání vrátí get_profile přesně stejnou hodnotu jako při prvním provedení a bude vybrána stejná cesta.

Nyní to porovnej s touto verzí, která vypadá neškodně, ale všechno rozbije.

import datetime
import random

@workflows.workflow.define(name="non_deterministic_workflow")
class NonDeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # ZAKÁZÁNO: datetime.now() se při každém provedení mění
        if datetime.datetime.now().hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # ZAKÁZÁNO: random.random() pokaždé vrátí jiný výsledek
        if random.random() > 0.5:
            await send_notification(user_id)
        
        return {"status": "completed"}

Představ si, že worker spadne v 11:58 dopoledne a restartuje se ve 12:03 odpoledne. Při přehrávání vrátí datetime.now() odpolední čas, zatímco historie obsahuje volání send_morning_email. Pracovní postup selže. random.random() má stejný efekt, jen hůře se diagnostikuje.

Náhrady v SDK

SDK nejen zakazuje tato volání, ale poskytuje deterministické ekvivalenty pro tři nejčastější operace.

from mistralai.workflows import workflow

# Získání aktuálního času (deterministické během přehrávání)
current_time = workflow.now()          # Místo datetime.now()

# Generování unikátního ID (deterministické během přehrávání)
request_id = workflow.uuid4()          # Místo uuid.uuid4()

# Získání náhodného čísla (deterministické během přehrávání)
rand_value = workflow.random()         # Místo random.random()

Princip je stejný jako u aktivit: hodnota se vypočítá a zaznamená do žurnálu při prvním provedení a následně se pouze přehraje. Předchozí příklad se pak stává zcela bezpečným.

import mistralai.workflows as workflows
from mistralai.workflows import workflow

@workflows.workflow.define(name="fixed_workflow")
class FixedWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # SPRÁVNĚ: workflow.now() je během přehrávání deterministické
        current_hour = workflow.now()
        if current_hour.hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # SPRÁVNĚ: workflow.random() je během přehrávání deterministické
        if workflow.random() > 0.5:
            await send_notification(user_id)
        
        # SPRÁVNĚ: workflow.uuid4() je během přehrávání deterministické
        trace_id = workflow.uuid4()
        await log_trace(str(trace_id), user_id)
        
        return {"status": "completed", "trace_id": str(trace_id)}

Hranice, na kterou si musíš pamatovat

V kódu pracovního postupu jsou zakázány následující prvky: datetime.now(), datetime.utcnow() a time.time(); uuid.uuid4() a uuid.uuid1(); random.random(), random.randint() a random.choice(); jakékoli přímé síťové volání (httpx, aiohttp, requests); jakékoli čtení nebo zápis souboru (open(), aiofiles); jakýkoli přístup k databázi; os.environ, protože proměnné prostředí se mohou mezi přehráváními měnit; a nakonec threading a multiprocessing, protože platforma řeší vnitřní paralelismus sama.

Všechno reprodukovatelné zůstává povoleno: volání aktivit přes await, používání workflow.now(), workflow.uuid4() a workflow.random(), psaní podmíněné logiky nebo smyček, jejichž podmínky závisí na výsledcích aktivit, manipulace s daty v paměti (výpočty, řetězce) a logování – logování je považováno za přijatelný vedlejší efekt.

Diagnostika chyby nedeterminismu

Když tato chyba nastane, obvykle stačí čtyři kontroly k jejímu nalezení.

  1. Přítomnost nedeterministických volání – Hledej v kódu pracovního postupu datetime.now, uuid.uuid4, random.random.
  2. Přímé I/O – Jakékoli síťové nebo souborové volání musí být umístěno v aktivitě.
  3. Proměnné prostředí – Pokud používáš os.environ pro větvení, přesuň čtení do aktivity.
  4. Knihovny třetích stran – Některé knihovny interně provádějí síťová volání nebo používají náhodnost.

Tento poslední bod je nejzákeřnější: serializační knihovna, která třídí podle náhodně generovaného ID, nebo HTTP klient instantiovaný při načtení modulu, může způsobit selhání přehrávání, aniž by se v tvém pracovním postupu objevila jediná podezřelá řádka.

Nejúčinnější obranou je udržovat pracovní postup co nejštíhlejší a přesouvat veškerou složitou logiku do aktivit. Pracovní postup, který pouze řetězí tři volání, nemá mechanicky žádnou příležitost být nedeterministický.

# OSVĚDČENÝ POSTUP: jednoduchý pracovní postup, logika v aktivitách
@workflows.workflow.define(name="simple_pipeline")
class SimplePipeline:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        step1 = await prepare_data(params)
        step2 = await process_data(step1)
        step3 = await finalize(step2)
        return step3

Klíčové poznatky

  • Kód pracovního postupu musí být deterministický: stejné vstupy = stejná sekvence operací.
  • Místo standardních ekvivalentů v Pythonu používej workflow.now(), workflow.uuid4() a workflow.random().
  • Všechny operace I/O (síť, soubory, DB) musí být umístěny v aktivitě, nikdy přímo v pracovním postupu.
  • Podmíněné větve jsou povoleny, pokud závisí na výsledcích aktivit.
  • Porušení determinismu způsobí selhání pracovního postupu během přehrávání.
  • Pokud si nejsi jistý, přesuň logiku do aktivity.