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

Canalización de streaming del LLM al TTS

Lección 12 de 14 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Conecta un LLM a la síntesis de voz en tiempo real
  2. Arquitectura de la canalización
  3. Implementación en Python
  4. Estrategia de búfer
  5. Reproducción de audio en tiempo real
  6. Gestión de errores en la canalización
  7. Puntos clave

Actualizado el 3 de noviembre de 2026, según la página Text to Speech de xAI: cada text.delta puede 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