Ir al contenido principal
Español— Elegir un idioma
Menú

La regla del determinismo

Lección 8 de 14 Actualizado el 2 de noviembre de 2026 Avanzado
En esta página
  1. Por qué el determinismo es obligatorio
  2. Cómo se ve esto en el código
  3. Sustitutos del SDK
  4. El límite que debes recordar
  5. Diagnosticar un error de no determinismo
  6. Puntos clave

Por qué el determinismo es obligatorio

El determinismo es la restricción más crítica en los flujos de trabajo de Mistral y se deriva directamente del mecanismo de repetición que has aprendido anteriormente. Cuando un worker reanuda un flujo de trabajo interrumpido, vuelve a ejecutar el código del flujo desde el principio y compara, operación por operación, lo que produce el código con lo registrado en el historial. Mientras las dos secuencias coincidan, la reanudación es invisible. En el momento en que divergen, la plataforma no tiene forma de saber dónde se quedó: detecta la inconsistencia y hace fallar el flujo de trabajo con un error de no determinismo.

En la práctica, un flujo de trabajo determinista produce exactamente la misma secuencia de operaciones cada vez que se ejecuta con las mismas entradas. Observa el matiz: los resultados de las actividades pueden variar entre ejecuciones, ya que provienen del diario. Lo que debe permanecer idéntico es el orden de las llamadas.

Cómo se ve esto en el código

Considera un flujo de trabajo que envía un informe a un usuario en función de su estado de suscripción.

@workflows.workflow.define(name="deterministic_workflow")
class DeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # Siempre la misma secuencia de llamadas para la misma entrada
        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"}

Este flujo de trabajo es determinista aunque contiene una bifurcación. La razón radica en el origen de la condición: profile["premium"] proviene del resultado de una actividad, por lo tanto, viene del diario. Durante la repetición, get_profile devuelve exactamente el mismo valor que en la primera ejecución y se toma el mismo camino.

Ahora compáralo con esta versión, que parece inofensiva pero lo rompe todo.

import datetime
import random

@workflows.workflow.define(name="non_deterministic_workflow")
class NonDeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # PROHIBIDO: datetime.now() cambia en cada ejecución
        if datetime.datetime.now().hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # PROHIBIDO: random.random() produce un resultado diferente cada vez
        if random.random() > 0.5:
            await send_notification(user_id)
        
        return {"status": "completed"}

Imagina que el worker falla a las 11:58 y se reinicia a las 12:03. En la repetición, datetime.now() devuelve una hora de la tarde, mientras que el historial contiene una llamada a send_morning_email. El flujo de trabajo falla. random.random() produce el mismo efecto, solo que es más difícil de diagnosticar.

Sustitutos del SDK

El SDK no solo prohíbe estas llamadas; proporciona equivalentes deterministas para las tres operaciones más comunes.

from mistralai.workflows import workflow

# Obtener la hora actual (determinista durante la repetición)
current_time = workflow.now()          # En lugar de datetime.now()

# Generar un ID único (determinista durante la repetición)
request_id = workflow.uuid4()          # En lugar de uuid.uuid4()

# Obtener un número aleatorio (determinista durante la repetición)
rand_value = workflow.random()         # En lugar de random.random()

El principio es el mismo que para las actividades: el valor se calcula y se registra en el diario en la primera ejecución, y luego simplemente se repite. El ejemplo anterior se vuelve entonces perfectamente seguro.

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:
        # CORRECTO: workflow.now() es determinista durante la repetición
        current_hour = workflow.now()
        if current_hour.hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # CORRECTO: workflow.random() es determinista durante la repetición
        if workflow.random() > 0.5:
            await send_notification(user_id)
        
        # CORRECTO: workflow.uuid4() es determinista durante la repetición
        trace_id = workflow.uuid4()
        await log_trace(str(trace_id), user_id)
        
        return {"status": "completed", "trace_id": str(trace_id)}

El límite que debes recordar

Lo siguiente está prohibido en el código del flujo de trabajo: datetime.now(), datetime.utcnow() y time.time(); uuid.uuid4() y uuid.uuid1(); random.random(), random.randint() y random.choice(); cualquier llamada de red directa (httpx, aiohttp, requests); cualquier lectura o escritura de archivos (open(), aiofiles); cualquier acceso a base de datos; os.environ, porque las variables de entorno pueden cambiar entre repeticiones; y finalmente threading y multiprocessing, ya que la plataforma gestiona el paralelismo interno.

Todo lo reproducible sigue estando permitido: llamar a actividades mediante await, usar workflow.now(), workflow.uuid4() y workflow.random(), escribir lógica condicional o bucles cuyas condiciones dependan de resultados de actividades, manipular datos en memoria (cálculos, cadenas) y registrar eventos; el registro se considera un efecto secundario aceptable.

Diagnosticar un error de no determinismo

Cuando aparece el error, cuatro comprobaciones suelen bastar para localizarlo.

  1. Presencia de llamadas no deterministas — Busca datetime.now, uuid.uuid4, random.random en el código del flujo de trabajo.
  2. E/S directa — Cualquier llamada de red o de archivo debe residir en una actividad.
  3. Variables de entorno — Si usas os.environ para bifurcar la lógica, mueve la lectura a una actividad.
  4. Bibliotecas de terceros — Algunas bibliotecas realizan llamadas de red o usan aleatoriedad internamente.

Este último punto es el más insidioso: una biblioteca de serialización que ordena por un ID generado aleatoriamente, o un cliente HTTP instanciado al cargar el módulo, puede hacer fallar una repetición sin que aparezca ni una sola línea sospechosa en tu flujo de trabajo.

La defensa más eficaz consiste en mantener el flujo de trabajo lo más ligero posible y delegar toda la lógica compleja en actividades. Un flujo de trabajo que simplemente encadena tres llamadas no tiene mecánicamente ninguna oportunidad de ser no determinista.

# MEJOR PRÁCTICA: flujo de trabajo simple, lógica en actividades
@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

Puntos clave

  • El código del flujo de trabajo debe ser determinista: mismas entradas = misma secuencia de operaciones.
  • Usa workflow.now(), workflow.uuid4(), workflow.random() en lugar de los equivalentes estándar de Python.
  • Todas las operaciones de E/S (red, archivo, BD) deben residir en una actividad, nunca en el flujo de trabajo.
  • Las bifurcaciones condicionales están permitidas si dependen de resultados de actividades.
  • Una violación del determinismo hace que el flujo de trabajo falle durante la repetición.
  • En caso de duda, mueve la lógica a una actividad.