Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Pipeline di streaming da LLM a TTS

Lezione 12 di 14 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Collega un LLM alla sintesi vocale in tempo reale
  2. Architettura della pipeline
  3. Implementazione in Python
  4. Strategia di buffering
  5. Riproduzione audio in tempo reale
  6. Gestione degli errori nella pipeline
  7. Punti chiave

Aggiornato il 3 novembre 2026, basato sulla pagina Text to Speech di xAI: ogni text.delta può 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