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

Control de la latencia

Lección 12 de 16 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. La disyuntiva entre latencia y precisión
  2. El parámetro target_streaming_delay_ms
  3. El patrón de Doble Retraso (Dual Delay)
  4. Gestión del reemplazo en pantalla
  5. Elección de la latencia adecuada para tu caso de uso
  6. Medición de la latencia real alcanzada
  7. Puntos clave

Curso actualizado el 3 de noviembre de 2026 para Voxtral 3, basado en la guía Migrate from Voxtral 2 de Mistral: los modelos de Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), obsoletos desde el 31 de octubre de 2026 y retirados el 30 de abril de 2027, se sustituyen en los ejemplos por voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 y voxtral-mini-tts-3-0. Cambios clave: marca de tiempo solo por segmento (word devuelve un error 400), la diarización en tiempo real es posible, la configuración de la sesión en tiempo real se bloquea tras el primer fragmento de audio y las entradas de context_bias son de formato libre (frases con espacios). Fuentes: Migrate from Voxtral 2 · Speech to Text.

La disyuntiva entre latencia y precisión

La transcripción en tiempo real depende de una disyuntiva inevitable: la velocidad de respuesta se logra a costa de la precisión. Cuanto más espera el modelo antes de emitir una palabra, más contexto tiene para distinguir entre hipótesis acústicas similares, y más tiempo debe esperar tu usuario. Una frase como «he took the sea» frente a «he took the bitter» puede solo aclararse por lo que sigue; un modelo apresurado a veces elegirá la incorrecta.

Voxtral Realtime no oculta esta disyuntiva tras una configuración automática: te la entrega explícitamente mediante el parámetro target_streaming_delay_ms. Tú decides el punto de equilibrio, caso por caso.

El parámetro target_streaming_delay_ms

Este valor expresa en milisegundos el retraso objetivo entre la recepción del audio y la emisión del texto correspondiente. Con Voxtral 3, acepta cualquier entero desde 80 hasta 1.200, o 2.400; cualquier otro valor desencadena un evento de error. Lo pasas directamente a la llamada de streaming, igual que el modelo y el formato de audio y, como toda configuración de sesión, se bloquea tras el primer fragmento de audio:

import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

# Baja latencia: respuesta rápida, menos precisa
async for event in client.audio.realtime.transcribe_stream(
    audio_stream=source_audio,
    model="voxtral-mini-transcribe-realtime-3",
    audio_format=audio_format,
    target_streaming_delay_ms=240,  # 240 ms
):
    if isinstance(event, TranscriptionStreamTextDelta):
        print(event.text, end="", flush=True)

Tres rangos de valores cubren casi todos los casos de uso. Entre 200 y 300 milisegundos, la transcripción es ultra responsiva: esta es la configuración para asistentes de voz, donde la inmediatez es lo más importante y el texto puede contener más correcciones. Entre 500 y 1.000 milisegundos, obtienes un buen equilibrio, adecuado para subtítulos en directo y dictado. Más allá de eso, entre 2.000 y 3.000 milisegundos, el modelo trabaja con mucho más contexto y produce un texto significativamente más limpio, a costa de un retraso que el usuario percibe claramente.

El patrón de Doble Retraso (Dual Delay)

¿Realmente tienes que elegir? Voxtral Realtime ofrece una solución alternativa: lanza dos flujos en paralelo sobre el mismo audio, con diferentes latencias, y rechaza así la disyuntiva. El flujo rápido, configurado por ejemplo a 240 milisegundos, ofrece una retroalimentación visual inmediata que tranquiliza al usuario y muestra que el sistema está escuchando. El flujo lento, configurado a 2.400 milisegundos, produce una transcripción más precisa que reemplaza gradualmente el texto provisional.

Conoces este comportamiento aunque no le hayas puesto nombre: así funcionan los subtítulos en directo en YouTube o Google Meet, donde el texto aparece casi al instante y luego se corrige unos momentos después. La implementación consiste en definir dos corrutinas idénticas salvo por el retraso y ejecutarlas juntas con asyncio.gather.

import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)

async def dual_latency_stream(source_audio_fast, source_audio_slow):
    """Ejecuta dos transcripciones en paralelo con diferentes latencias."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    results = {"fast": [], "slow": []}

    async def fast_stream():
        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=source_audio_fast,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
            target_streaming_delay_ms=240,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                results["fast"].append(event.text)
                # Mostrar inmediatamente (será reemplazado por el flujo lento)
                print(f"\r[FAST] {''.join(results['fast'][-10:])}",
                      end="", flush=True)

    async def slow_stream():
        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=source_audio_slow,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
            target_streaming_delay_ms=2400,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                results["slow"].append(event.text)
                # Mostrar versión corregida
                print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
                      flush=True)

    # Ejecutar ambos flujos en paralelo
    await asyncio.gather(fast_stream(), slow_stream())

    return {
        "fast": "".join(results["fast"]),
        "slow": "".join(results["slow"])
    }

Ten en cuenta que la función recibe dos fuentes de audio separadas, no una: un generador asíncrono solo puede consumirse una vez, por lo que debes duplicar el flujo aguas arriba para alimentar ambas transcripciones.

Gestión del reemplazo en pantalla

En un terminal, la doble salida del código anterior es suficiente para entender el mecanismo, pero una interfaz real debe fusionar los dos flujos en un único texto legible. La convención establecida es mostrar el texto provisional en un tono sutil —gris— y el texto confirmado en blanco, avanzando el límite entre ellos a medida que el flujo lento alcanza al rápido. La clase siguiente implementa este límite con final_position: todo lo anterior proviene del flujo lento y no cambiará; todo lo posterior proviene del flujo rápido y sigue sujeto a corrección.

class DualLatencyDisplay:
    """Gestiona la visualización con doble latencia."""

    def __init__(self):
        self.fast_text = ""
        self.final_text = ""
        self.final_position = 0

    def on_fast_text(self, text: str):
        """Nuevo texto del flujo rápido (provisional)."""
        self.fast_text += text
        self._display()

    def on_slow_text(self, text: str):
        """Nuevo texto del flujo lento (final)."""
        self.final_text += text
        self.final_position = len(self.final_text)
        self._display()

    def _display(self):
        """Muestra el texto final más el texto rápido aún no confirmado."""
        provisional_text = self.fast_text[self.final_position:]
        display = self.final_text + provisional_text
        print(f"\r{display}", end="", flush=True)

Esta comodidad tiene un coste que sería deshonesto ignorar: dos flujos significan dos conexiones y el doble de volumen de audio procesado. Reserva el patrón Dual Delay para interfaces donde el usuario lee el texto a medida que ocurre; para el procesamiento en segundo plano, un único flujo bien ajustado es más que suficiente.

Elección de la latencia adecuada para tu caso de uso

Caso de usoLatencia recomendadaMotivo
Asistente de voz200-300 msEl usuario espera una reacción inmediata
Dictado por voz500-800 msEquilibrio entre capacidad de respuesta y precisión
Subtítulos en directo800-1.200 msLa precisión es importante, un ligero retraso es aceptable
Transcripción de conferencias1.200 o 2.400 msMáxima precisión, el retraso no es crítico

Medición de la latencia real alcanzada

El valor que solicitas es un objetivo, no una garantía: la distancia de red, la carga del servicio y el tamaño de tus fragmentos se suman a él. Antes de citar una cifra a tus usuarios, mídela desde donde se ejecutará realmente tu aplicación. La función siguiente cronometra el retraso hasta que llega el primer fragmento y lo compara con el objetivo solicitado.

import time

async def measure_latency(source_audio, delay_ms):
    """Mide la latencia efectiva de la transcripción."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    start = time.time()
    first_text = None

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=source_audio,
        model="voxtral-mini-transcribe-realtime-3",
        audio_format=audio_format,
        target_streaming_delay_ms=delay_ms,
    ):
        if isinstance(event, TranscriptionStreamTextDelta):
            if first_text is None:
                first_text = time.time()
                latency = (first_text - start) * 1000
                print(f"Primer texto tras {latency:.0f} ms "
                      f"(objetivo: {delay_ms} ms)")
            print(event.text, end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

    print(f"\nDuración total: {time.time() - start:.1f}s")

Ejecuta esta medición con 240, luego 800 y finalmente 2.400 milisegundos sobre el mismo extracto, y lee las tres transcripciones lado a lado. La brecha de calidad entre la primera y la última te indicará, mejor que cualquier recomendación general, qué latencia puede permitirse tu aplicación.

Puntos clave

  • target_streaming_delay_ms controla la disyuntiva entre latencia y precisión
  • Valores bajos (80 a 300 ms): responsivos pero menos precisos
  • Valores altos (1.200 ms o 2.400 ms): precisos pero con retraso perceptible; solo se aceptan valores de 80 a 1.200 y 2.400
  • El patrón Dual Delay combina dos flujos para lograr tanto capacidad de respuesta COMO precisión
  • El flujo rápido ofrece retroalimentación inmediata, el flujo lento corrige el texto
  • Elige la latencia en función de tu caso de uso (asistente de voz frente a subtítulos)