Streaming en tiempo real
En esta página
Curso actualizado el 3 de noviembre de 2026 para Voxtral TTS 3, basándose en la guía Migrate from Voxtral 2 y las páginas de Text to Speech de Mistral:
voxtral-mini-tts-2603, obsoleto desde el 31 de octubre de 2026 y retirado el 30 de abril de 2027, se sustituye en los ejemplos porvoxtral-mini-tts-3-0. Las voces predefinidas de Voxtral 2 (gb_jane_neutral…) siguen siendo compatibles; Voxtral 3 añade las etiquetas[emotion=…]y[pace=…]en el texto, la configuraciónexpressiveness, la pronunciación personalizada (phoneme_hints) y 35 idiomas. Mistral recomienda volver a medir la latencia tras la migración. Fuentes: Migrate from Voxtral 2 · Speech generation.
Por qué el streaming lo cambia todo
Hasta ahora has trabajado en modo síncrono: envías el texto, esperas a que la síntesis termine por completo y luego recibes el archivo de audio completo. Para un saludo pregenerado creado el día anterior, esta espera no importa. Para un asistente de voz que responde a un cliente por teléfono, es un problema insalvable: dos segundos de silencio tras una pregunta y el usuario piensa que la llamada se ha cortado.
El streaming elimina esta espera. El audio se envía a medida que se genera, fragmento a fragmento, de modo que el usuario oye las primeras palabras mientras el modelo aún está produciendo el final de la frase. El tiempo total de generación no cambia; lo que se reduce drásticamente es el retraso antes del primer sonido.
El protocolo de eventos
El flujo se basa en Server-Sent Events. Cada mensaje recibido es un evento tipado, y dos tipos te conciernen:
speech.audio.delta: contiene un fragmento de audio en base64. Este es el evento principal que gestionarás.speech.audio.done: señal de fin; la generación ha concluido.
En el código, cambiar a streaming implica añadir stream=True y consumir la respuesta dentro de un bloque with. El siguiente ejemplo acumula fragmentos en memoria para escribir un archivo al final: esto aún no es tiempo real, pero es la estructura de bucle sobre la que se construirá el resto de la lección.
import base64
from pathlib import Path
from mistralai.client import Mistral
client = Mistral(api_key="your-api-key")
audio_chunks = []
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input="Streaming makes voice agents responsive and natural.",
voice_id="your-voice-id",
response_format="opus",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
chunk = base64.b64decode(event.data.audio_data)
audio_chunks.append(chunk)
print(f"Fragmento recibido: {len(chunk)} bytes")
# Ensamblar todos los fragmentos
audio_complet = b"".join(audio_chunks)
Path("streaming-output.opus").write_bytes(audio_complet)
print(f"Audio final: {len(audio_complet)} bytes")
Reproducir el sonido a medida que llega
Para conseguir la capacidad de respuesta prometida, deja de acumular y escribe cada fragmento directamente en la tarjeta de sonido. Con pyaudio, el cambio requiere una línea: en lugar de añadir el fragmento decodificado a una lista, lo envías a un flujo de salida abierto previamente, configurado para Float32 mono a 24.000 Hz.
import base64
import pyaudio
from mistralai.client import Mistral
client = Mistral(api_key="your-api-key")
# Configuración de audio PCM (formato más rápido)
p = pyaudio.PyAudio()
stream_audio = p.open(
format=pyaudio.paFloat32,
channels=1,
rate=24000,
output=True,
)
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input="You're hearing this sentence while I generate it.",
voice_id="your-voice-id",
response_format="pcm",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
audio_data = base64.b64decode(event.data.audio_data)
stream_audio.write(audio_data)
stream_audio.stop_stream()
stream_audio.close()
p.terminate()
El formato solicitado ha cambiado de opus a pcm, y eso importa. PCM no necesita decodificación: los bytes recibidos están listos para reproducirse inmediatamente, lo que lo convierte en el formato recomendado para uso en tiempo real.
Retransmitir el flujo a un navegador
En una aplicación web, el servidor no reproduce el sonido: lo retransmite. El patrón clásico utiliza un WebSocket que recibe texto del navegador, abre el flujo de Voxtral y empuja cada fragmento decodificado de vuelta al cliente. En el lado del navegador, la API Web Audio se encarga de reproducir los fragmentos PCM recibidos.
# Lado del servidor (ejemplo con FastAPI)
from fastapi import FastAPI, WebSocket
import base64
from mistralai.client import Mistral
app = FastAPI()
client = Mistral(api_key="your-api-key")
@app.websocket("/ws/tts")
async def tts_websocket(websocket: WebSocket):
await websocket.accept()
texte = await websocket.receive_text()
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input=texte,
voice_id="your-voice-id",
response_format="pcm",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
await websocket.send_bytes(
base64.b64decode(event.data.audio_data)
)
await websocket.close()
La configuración que marca la diferencia: el búfer
Los tamaños de los fragmentos varían y suelen representar unos pocos milisegundos de audio cada uno. Si reproduces el primer fragmento en el instante en que llega, cualquier irregularidad de la red provoca una microinterrupción audible —un tartamudeo en la voz que delata inmediatamente a la máquina. La solución es almacenar en búfer dos o tres fragmentos antes de iniciar la reproducción; esto cuesta unas pocas decenas de milisegundos y suaviza el resto del flujo.
Luego está la elección del formato, que equilibra latencia frente a ancho de banda. PCM ofrece el primer sonido más rápido —alrededor de 0,7 segundos en mediciones realizadas con Voxtral 2, por volver a hacer con Voxtral TTS 3— a costa de un alto throughput. Opus pierde un poco en latencia pero comprime mucho, lo que lo convierte en el compromiso adecuado cuando tus usuarios están en móviles.
Puntos clave
- El streaming envía audio fragmento a fragmento durante la generación
- Actívalo con
stream=Trueen la llamada aaudio.speech.complete() - Los eventos
speech.audio.deltacontienen fragmentos de audio en base64 - El formato PCM ofrece la menor latencia para streaming (~0,7 s frente a ~2 s para MP3)
- Para reproducción en tiempo real, usa
pyaudioo WebSockets + Web Audio API