Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

De regel van determinisme

Les 8 van 14 Bijgewerkt op 2 november 2026 Gevorderd
Op deze pagina
  1. Waarom determinisme verplicht is
  2. Hoe dit eruitziet in code
  3. Vervangingen in de SDK
  4. De grens om te onthouden
  5. Een non-determinisme-fout diagnosticeren
  6. Belangrijkste punten

Waarom determinisme verplicht is

Determinisme is de belangrijkste beperking in Mistral-workflows. Dit volgt rechtstreeks uit het replay-mechanisme dat u eerder hebt geleerd. Wanneer een worker een onderbroken workflow hervat, speelt deze de workflow-code vanaf het begin opnieuw af en vergelijkt deze, operatie voor operatie, wat de code produceert met wat het geschiedenislogboek heeft vastgelegd. Zolang de twee reeksen overeenkomen, is de hervatting onzichtbaar. Zodra ze divergeren, heeft het platform geen manier meer om te weten waar het was gebleven: het detecteert de inconsistentie en laat de workflow falen met een non-determinisme-fout.

In de praktijk produceert een deterministische workflow bij elke uitvoering met dezelfde inputs exact dezelfde reeks operaties. Let op de nuance: activiteitsresultaten kunnen variëren tussen uitvoeringen omdat ze uit het logboek komen. Het is de volgorde van aanroepen die identiek moet blijven.

Hoe dit eruitziet in code

Neem een workflow die een rapport naar een gebruiker stuurt op basis van hun abonnementsstatus.

@workflows.workflow.define(name="deterministic_workflow")
class DeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # Altijd dezelfde volgorde van aanroepen voor dezelfde input
        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"}

Deze workflow is deterministisch, ook al bevat deze een vertakking. De reden ligt in de bron van de voorwaarde: profile["premium"] komt uit een activiteitsresultaat en dus uit het logboek. Tijdens replay geeft get_profile exact dezelfde waarde terug als bij de eerste uitvoering, waardoor hetzelfde pad wordt gevolgd.

Vergelijk dit nu met deze versie, die onschuldig lijkt maar alles laat mislukken.

import datetime
import random

@workflows.workflow.define(name="non_deterministic_workflow")
class NonDeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # VERBODEN: datetime.now() verandert bij elke uitvoering
        if datetime.datetime.now().hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # VERBODEN: random.random() levert elke keer een ander resultaat op
        if random.random() > 0.5:
            await send_notification(user_id)
        
        return {"status": "completed"}

Stel dat de worker crasht om 11:58 uur en herstart om 12:03 uur. Bij replay geeft datetime.now() een middagtijd terug, terwijl de geschiedenis een aanroep naar send_morning_email bevat. De workflow faalt. random.random() heeft hetzelfde effect, alleen is dit moeilijker te diagnosticeren.

Vervangingen in de SDK

De SDK verbiedt deze aanroepen niet alleen; deze biedt deterministische equivalenten voor de drie meest voorkomende bewerkingen.

from mistralai.workflows import workflow

# Huidige tijd ophalen (deterministisch tijdens replay)
current_time = workflow.now()          # In plaats van datetime.now()

# Een unieke ID genereren (deterministisch tijdens replay)
request_id = workflow.uuid4()          # In plaats van uuid.uuid4()

# Een willekeurig getal ophalen (deterministisch tijdens replay)
rand_value = workflow.random()         # In plaats van random.random()

Het principe is hetzelfde als bij activiteiten: de waarde wordt berekend en vastgelegd in het logboek bij de eerste uitvoering, en daarna eenvoudigweg afgespeeld. Het vorige voorbeeld wordt dan volkomen veilig.

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:
        # CORRECT: workflow.now() is deterministisch tijdens replay
        current_hour = workflow.now()
        if current_hour.hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # CORRECT: workflow.random() is deterministisch tijdens replay
        if workflow.random() > 0.5:
            await send_notification(user_id)
        
        # CORRECT: workflow.uuid4() is deterministisch tijdens replay
        trace_id = workflow.uuid4()
        await log_trace(str(trace_id), user_id)
        
        return {"status": "completed", "trace_id": str(trace_id)}

De grens om te onthouden

Het volgende is verboden in workflow-code: datetime.now(), datetime.utcnow() en time.time(); uuid.uuid4() en uuid.uuid1(); random.random(), random.randint() en random.choice(); elke directe netwerkaanroep (httpx, aiohttp, requests); elk bestand lezen of schrijven (open(), aiofiles); elke database-toegang; os.environ, omdat omgevingsvariabelen kunnen veranderen tussen replays; en tot slot threading en multiprocessing, aangezien het platform interne parallelle verwerking afhandelt.

Alles wat reproduceerbaar is, blijft toegestaan: activiteiten aanroepen via await, gebruikmaken van workflow.now(), workflow.uuid4() en workflow.random(), conditionele logica of lussen schrijven waarvan de voorwaarden afhangen van activiteitsresultaten, gegevens in het geheugen manipuleren (berekeningen, strings) en loggen—loggen wordt beschouwd als een acceptabel neveneffect.

Een non-determinisme-fout diagnosticeren

Wanneer de fout optreedt, volstaan vier controles meestal om de oorzaak te lokaliseren.

  1. Aanwezigheid van non-deterministische aanroepen — Zoek naar datetime.now, uuid.uuid4, random.random in de workflow-code
  2. Directe I/O — Elke netwerk- of bestandsaanroep moet in een activiteit zitten
  3. Omgevingsvariabelen — Als u os.environ gebruikt voor vertakkingen, verplaats het lezen dan naar een activiteit
  4. Bibliotheken van derden — Sommige bibliotheken doen netwerkaanroepen of gebruiken intern willekeurigheid

Dit laatste punt is het meest verraderlijk: een serialisatiebibliotheek die sorteert op een willekeurig gegenereerde ID, of een HTTP-client die bij het laden van de module wordt geïnstantieerd, kan een replay laten mislukken zonder dat er een enkele verdachte regel in uw workflow verschijnt.

De meest effectieve verdediging is de workflow zo sober mogelijk houden en alle complexe logica naar activiteiten verplaatsen. Een workflow die simpelweg drie aanroepen ketent, heeft mechanisch gezien geen enkele kans om non-deterministisch te zijn.

# BESTE PRAKTIJK: eenvoudige workflow, logica in activiteiten
@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

Belangrijkste punten

  • Workflow-code moet deterministisch zijn: dezelfde inputs = dezelfde reeks operaties
  • Gebruik workflow.now(), workflow.uuid4(), workflow.random() in plaats van standaard Python-equivalenten
  • Alle I/O-bewerkingen (netwerk, bestand, DB) moeten in een activiteit zitten, nooit in de workflow
  • Conditionele vertakkingen zijn toegestaan als ze afhangen van activiteitsresultaten
  • Een schending van het determinisme zorgt ervoor dat de workflow faalt tijdens replay
  • Bij twijfel: verplaats de logica naar een activiteit