Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Pipeline de streaming do LLM para TTS

Aula 12 de 14 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Ligar um LLM à síntese de voz em tempo real
  2. Arquitetura do pipeline
  3. Implementação em Python
  4. Estratégia de buffering
  5. Reprodução de áudio em tempo real
  6. Tratamento de erros no pipeline
  7. Pontos-chave

Atualizado em 3 de novembro de 2026, com base na página Text to Speech da xAI: cada text.delta pode conter até 60.000 carateres. Fonte: Text to Speech.

Ligar um LLM à síntese de voz em tempo real

A utilização mais poderosa do WebSocket de TTS consiste em encadeá-lo com um LLM em streaming. O LLM gera texto token a token, cada token é enviado para o TTS via WebSocket e o áudio é reproduzido à medida que chega. O utilizador ouve a resposta enquanto o LLM ainda está a processar.

Arquitetura do pipeline

Os dados fluem através de três fases:

User -> LLM (streaming) -> TTS WebSocket -> Audio (playback)
question   text tokens        audio.delta       speaker

Cada fase opera em streaming, o que minimiza a latência percecionada. O utilizador não precisa de esperar que o LLM termine de gerar toda a resposta para começar a ouvi-la.

Implementação em Python

Eis um pipeline completo que liga a API Grok Chat Completions ao 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"):
    # Passo 1: Ligação ao 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:

        # Passo 2: Chamada ao LLM em 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:

                # Passo 3: Cada token do 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
                        # Enviar frases completas
                        if any(c in token for c in ".!?\n"):
                            await tts_ws.send(json.dumps({
                                "type": "text.delta",
                                "delta": buffer
                            }))
                            buffer = ""

                # Enviar o que restar no buffer
                if buffer:
                    await tts_ws.send(json.dumps({
                        "type": "text.delta",
                        "delta": buffer
                    }))

                await tts_ws.send(json.dumps({"type": "text.done"}))

        # Passo 4: Recolher o áudio
        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)

Estratégia de buffering

Enviar cada token individualmente para o TTS não é ideal: o motor de síntese produz resultados melhores quando dispõe de contexto. Existem três estratégias de buffering.

Por frase

Aguarde por um delimitador de frase (., !, ?, quebra de linha) 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 é o melhor equilíbrio entre qualidade e latência.

Por tamanho

Envie quando o buffer atingir um determinado tamanho (200 carateres, por exemplo):

if len(buffer) >= 200:
    await tts_ws.send(json.dumps({
        "type": "text.delta", "delta": buffer
    }))
    buffer = ""

É mais simples, mas pode cortar uma palavra a meio.

Por tempo limite

Envie após um atraso sem novos tokens (útil enquanto o LLM está a pensar):

last_token_time = time.time()

# Se passarem mais de 500 ms sem um token, envie o buffer
if time.time() - last_token_time > 0.5 and buffer:
    await tts_ws.send(...)
    buffer = ""

Reprodução de áudio em tempo real

Para reproduzir o áudio à medida que chega (e não apenas recolhê-lo), utilize uma fila assíncrona:

import asyncio

audio_queue = asyncio.Queue()

async def receive_audio(tts_ws):
    """Recebe blocos de áudio e coloca-os na fila."""
    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)  # Sentinela de fim
            break

async def play_audio():
    """Reproduz blocos de áudio da fila."""
    while True:
        chunk = await audio_queue.get()
        if chunk is None:
            break
        # Reproduzir o bloco (pyaudio, sounddevice, etc.)
        play_chunk(chunk)

Ao executar receive_audio e play_audio em paralelo, a reprodução inicia-se com o primeiro bloco recebido.

Tratamento de erros no pipeline

O pipeline pode falhar em três locais: no LLM, no TTS ou na rede. Trate cada um deles:

async def robust_pipeline(api_key, prompt):
    try:
        audio = await llm_to_speech(api_key, prompt)
        return audio
    except aiohttp.ClientError:
        print("Erro no LLM: verifique a sua ligação")
    except websockets.ConnectionClosed:
        print("Ligação ao TTS perdida: é necessário reconectar")
    except json.JSONDecodeError:
        print("Resposta inválida: formato inesperado")
    except Exception as e:
        print(f"Erro inesperado: {e}")
    return None

Pontos-chave

  • Um LLM em streaming a alimentar o WebSocket de TTS proporciona a menor latência
  • Faça o buffering por frase para o melhor equilíbrio entre qualidade e latência
  • Utilize uma fila assíncrona para reprodução de áudio em tempo real
  • Trate os erros em cada fase do pipeline
  • O texto total via WebSocket é ilimitado (deltas de até 60.000 carateres)
  • O limite de 50 sessões simultâneas aplica-se a toda a sua equipa