Pipeline di streaming da LLM a TTS
In questa pagina
Aggiornato il 3 novembre 2026, basato sulla pagina Text to Speech di xAI: ogni
text.deltapuò contenere fino a 60.000 caratteri. Fonte: Text to Speech.
Collega un LLM alla sintesi vocale in tempo reale
L’utilizzo più potente del WebSocket TTS consiste nel collegarlo a un LLM in streaming. L’LLM genera il testo token per token, ogni token viene inviato al TTS tramite WebSocket e l’audio viene riprodotto man mano che arriva. L’utente ascolta la risposta mentre l’LLM sta ancora elaborando.
Architettura della pipeline
I dati fluiscono attraverso tre fasi:
User -> LLM (streaming) -> TTS WebSocket -> Audio (playback)
question text tokens audio.delta speaker
Ogni fase opera in streaming, riducendo al minimo la latenza percepita. L’utente non deve attendere che l’LLM finisca di generare l’intera risposta prima di iniziare ad ascoltarla.
Implementazione in Python
Ecco una pipeline completa che collega le API Chat Completions di Grok al WebSocket TTS:
import asyncio
import websockets
import json
import base64
import aiohttp
async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
# Step 1: Connessione WebSocket 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:
# Step 2: Chiamata LLM in 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:
# Step 3: Ogni token LLM -> delta 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
# Invia frasi complete
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# Invia qualsiasi contenuto rimasto nel buffer
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# Step 4: Raccolta dell'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)
Strategia di buffering
Inviare ogni token al TTS individualmente non è ideale: il motore di sintesi produce risultati migliori quando dispone di un contesto. Esistono tre strategie di buffering.
Per frase
Attendi un delimitatore di frase (., !, ?, interruzione di riga) prima di inviare:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Questo rappresenta il miglior equilibrio tra qualità e latenza.
Per dimensione
Invia quando il buffer raggiunge una certa dimensione (ad esempio 200 caratteri):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
È più semplice, ma può tagliare una parola a metà.
Per timeout
Invia dopo un ritardo senza nuovi token (utile mentre l’LLM sta pensando):
last_token_time = time.time()
# Se passano più di 500 ms senza un token, invia il buffer
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Riproduzione audio in tempo reale
Per riprodurre l’audio man mano che arriva (invece di limitarsi a raccoglierlo), usa una coda asincrona:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Riceve i chunk audio e li inserisce nella coda."""
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) # Sentinella di fine
break
async def play_audio():
"""Riproduce i chunk audio dalla coda."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# Riproduci il chunk (pyaudio, sounddevice, ecc.)
play_chunk(chunk)
Eseguendo receive_audio e play_audio in parallelo, la riproduzione inizia con il primo chunk ricevuto.
Gestione degli errori nella pipeline
La pipeline può fallire in tre punti: l’LLM, il TTS o la rete. Gestisci ciascuno di essi:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("Errore LLM: controlla la tua connessione")
except websockets.ConnectionClosed:
print("Connessione TTS persa: necessaria riconnessione")
except json.JSONDecodeError:
print("Risposta non valida: formato inaspettato")
except Exception as e:
print(f"Errore imprevisto: {e}")
return None
Punti chiave
- Un LLM in streaming che alimenta il WebSocket TTS garantisce la latenza più bassa
- Effettua il buffering per frase per il miglior equilibrio tra qualità e latenza
- Usa una coda asincrona per la riproduzione audio in tempo reale
- Gestisci gli errori in ogni fase della pipeline
- Il testo totale su WebSocket è illimitato (delta fino a 60.000 caratteri)
- Il limite di 50 sessioni concurrenti si applica all’intero team