Control de la latencia
En esta página
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 porvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3yvoxtral-mini-tts-3-0. Cambios clave: marca de tiempo solo por segmento (worddevuelve 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 decontext_biasson 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 uso | Latencia recomendada | Motivo |
|---|---|---|
| Asistente de voz | 200-300 ms | El usuario espera una reacción inmediata |
| Dictado por voz | 500-800 ms | Equilibrio entre capacidad de respuesta y precisión |
| Subtítulos en directo | 800-1.200 ms | La precisión es importante, un ligero retraso es aceptable |
| Transcripción de conferencias | 1.200 o 2.400 ms | Má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_mscontrola 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)