Canalización de streaming del LLM al TTS
En esta página
Actualizado el 3 de noviembre de 2026, según la página Text to Speech de xAI: cada
text.deltapuede contener hasta 60.000 caracteres. Fuente: Text to Speech.
Conecta un LLM a la síntesis de voz en tiempo real
El uso más potente del WebSocket de TTS consiste en encadenarlo a un LLM con streaming. El LLM genera texto token a token, cada token se envía al TTS a través de WebSocket y el audio se reproduce a medida que llega. El usuario escucha la respuesta mientras el LLM aún está «pensando».
Arquitectura de la canalización
Los datos fluyen a través de tres etapas:
Usuario -> LLM (streaming) -> WebSocket TTS -> Audio (reproducción)
pregunta tokens de texto audio.delta altavoz
Cada etapa funciona en modo streaming, lo que minimiza la latencia percibida. El usuario no tiene que esperar a que el LLM termine de generar toda su respuesta para empezar a escucharla.
Implementación en Python
A continuación se muestra una canalización completa que conecta la API de Chat Completions de Grok con el WebSocket de TTS:
import asyncio
import websockets
import json
import base64
import aiohttp
async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
# Paso 1: Conexión al WebSocket de TTS
tts_uri = f"wss://api.x.ai/v1/tts?language={language}&voice={voice}"
tts_headers = {"Authorization": f"Bearer {api_key}"}
audio_chunks = []
async with websockets.connect(tts_uri, additional_headers=tts_headers) as tts_ws:
# Paso 2: Llamada al LLM con streaming
async with aiohttp.ClientSession() as session:
async with session.post(
"https://api.x.ai/v1/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
},
json={
"model": "grok-4.5",
"messages": [{"role": "user", "content": prompt}],
"stream": True
}
) as llm_response:
# Paso 3: Cada token del LLM -> delta de TTS
buffer = ""
async for line in llm_response.content:
line = line.decode().strip()
if not line.startswith("data: "):
continue
if line == "data: [DONE]":
break
chunk = json.loads(line[6:])
token = chunk["choices"][0].get("delta", {}).get("content", "")
if token:
buffer += token
# Envía oraciones completas
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# Envía lo que quede en el búfer
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# Paso 4: Recopila el audio
async for msg in tts_ws:
data = json.loads(msg)
if data["type"] == "audio.delta":
audio_chunks.append(base64.b64decode(data["delta"]))
elif data["type"] == "audio.done":
break
return b"".join(audio_chunks)
Estrategia de búfer
Enviar cada token al TTS individualmente no es lo ideal: el motor de síntesis produce mejores resultados cuando dispone de contexto. Existen tres estrategias de búfer.
Por oración
Espera a un delimitador de oración (., !, ?, salto de línea) antes de enviar:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Este es el mejor equilibrio entre calidad y latencia.
Por tamaño
Envía cuando el búfer alcance un tamaño determinado (200 caracteres, por ejemplo):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Es más sencillo, pero puede cortar una palabra por la mitad.
Por tiempo de espera
Envía tras un retraso sin nuevos tokens (útil mientras el LLM está «pensando»):
last_token_time = time.time()
# Si pasan más de 500 ms sin un token, envía el búfer
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Reproducción de audio en tiempo real
Para reproducir el audio a medida que llega (en lugar de solo recopilarlo), utiliza una cola asíncrona:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Recibe fragmentos de audio y los coloca en la cola."""
async for msg in tts_ws:
data = json.loads(msg)
if data["type"] == "audio.delta":
audio_bytes = base64.b64decode(data["delta"])
await audio_queue.put(audio_bytes)
elif data["type"] == "audio.done":
await audio_queue.put(None) # Centinela de fin
break
async def play_audio():
"""Reproduce fragmentos de audio desde la cola."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# Reproduce el fragmento (pyaudio, sounddevice, etc.)
play_chunk(chunk)
Al ejecutar receive_audio y play_audio en paralelo, la reproducción comienza con el primer fragmento recibido.
Gestión de errores en la canalización
La canalización puede fallar en tres puntos: el LLM, el TTS o la red. Gestiona cada uno de ellos:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("Error del LLM: comprueba tu conexión")
except websockets.ConnectionClosed:
print("Conexión TTS perdida: se necesita reconexión")
except json.JSONDecodeError:
print("Respuesta no válida: formato inesperado")
except Exception as e:
print(f"Error inesperado: {e}")
return None
Puntos clave
- Un LLM con streaming que alimenta el WebSocket de TTS ofrece la menor latencia
- Utiliza el búfer por oración para el mejor equilibrio entre calidad y latencia
- Emplea una cola asíncrona para la reproducción de audio en tiempo real
- Gestiona los errores en cada etapa de la canalización
- El texto total a través de WebSocket es ilimitado (deltas de hasta 60.000 caracteres)
- El límite de 50 sesiones simultáneas se aplica a todo tu equipo