Streaming audio in tempo reale
In questa pagina
Aggiornamento 2 novembre 2026 — Modelli audio. Diversi modelli in questo corso sono deprecati:
tts-1,tts-1-hdegpt-4o-mini-ttssmetteranno di funzionare il 6 gennaio 2027 (successore:gpt-realtime-2.1-mini, che la guida OpenAI TTS definisce non supportato da/v1/audio/speech: la migrazione della sintesi vocale passa alle API Realtime);gpt-realtime,gpt-4o-realtimee i modelli audio legacy il 20 gennaio 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribee/v1/audio/translationsil 26 febbraio 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Per la voce full-duplex, GPT-Live 1 è disponibile nelle API dal 10 settembre 2026. Aggiornato il 3 novembre 2026: la pipeline LLM → TTS elaborava precedentemente qualsiasi evento contenente un campodelta, inclusi gli argomenti delle chiamate di funzione o i riepiloghi del ragionamento; ora filtra rigorosamente perresponse.output_text.delta, ovvero il testo effettivo della risposta.
Streaming audio in tempo reale
In un agente vocale, attendere la generazione dell’intero file audio prima di avviare la riproduzione introduce una latenza inaccettabile. Lo streaming TTS ti consente di avviare la riproduzione non appena arrivano i primi byte, riducendo il tempo per la prima risposta a poche centinaia di millisecondi.
Streaming con le API TTS
Le API TTS supportano nativamente lo streaming. Invece di attendere il file completo, ricevi l’audio in blocchi:
from openai import OpenAI
import pyaudio
client = OpenAI()
def stream_tts_to_speaker(text: str, voice: str = "alloy"):
"""Genera e riproduce audio in modalità streaming."""
# Inizializza il lettore audio
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
try:
# Crea la risposta in streaming
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm" # PCM grezzo per la riproduzione diretta
) as response:
# Leggi e riproduci blocco per blocco
for chunk in response.iter_bytes(chunk_size=4096):
player.write(chunk)
finally:
player.stop_stream()
player.close()
pa.terminate()
stream_tts_to_speaker("Hello, here is a real-time streaming response.")
Il formato pcm è ideale per lo streaming perché non richiede decodifica: i byte grezzi sono pronti per la riproduzione immediata.
Misurazione della latenza
Il Time to First Byte (TTFB) è la metrica chiave per le prestazioni dello streaming:
import time
def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
"""Misura le latenze dello streaming TTS."""
start_time = time.time()
first_byte_time = None
total_bytes = 0
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm"
) as response:
for chunk in response.iter_bytes(chunk_size=4096):
if first_byte_time is None:
first_byte_time = time.time()
total_bytes += len(chunk)
end_time = time.time()
return {
"ttfb_ms": round((first_byte_time - start_time) * 1000),
"total_ms": round((end_time - start_time) * 1000),
"total_bytes": total_bytes,
"audio_duration_s": round(total_bytes / (24000 * 2), 2)
}
metrics = measure_tts_latency("Hello, how are you?")
print(f"TTFB: {metrics['ttfb_ms']}ms, Total: {metrics['total_ms']}ms")
Streaming asincrono
Per le applicazioni lato server, utilizza il client asincrono:
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_tts_async(text: str, voice: str = "alloy"):
"""Streaming TTS asincrono per server."""
chunks = []
async with async_client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm"
) as response:
async for chunk in response.iter_bytes(chunk_size=4096):
chunks.append(chunk)
# Qui invieresti il blocco al client tramite WebSocket
yield chunk
# Utilizzo in un server FastAPI
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
app = FastAPI()
@app.get("/tts/stream")
async def tts_stream(text: str, voice: str = "alloy"):
return StreamingResponse(
stream_tts_async(text, voice),
media_type="audio/pcm"
)
Pre-caricamento del buffer
Per garantire una riproduzione fluida senza interruzioni, accumula un piccolo buffer prima di iniziare:
async def buffered_tts_playback(
text: str,
voice: str = "alloy",
buffer_size: int = 3 # Numero di blocchi da pre-caricare
):
"""Riproduzione TTS con buffer di pre-caricamento."""
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
buffer = []
playback_started = False
try:
async with async_client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm"
) as response:
async for chunk in response.iter_bytes(chunk_size=4096):
buffer.append(chunk)
if not playback_started and len(buffer) >= buffer_size:
playback_started = True
# Svuota il buffer iniziale
for buffered_chunk in buffer:
player.write(buffered_chunk)
buffer.clear()
elif playback_started:
player.write(chunk)
# Riproduci i blocchi rimanenti
for remaining in buffer:
player.write(remaining)
finally:
player.stop_stream()
player.close()
pa.terminate()
Integrazione con una pipeline LLM + TTS
In un agente vocale non basato su Realtime, puoi combinare lo streaming dell’LLM con lo streaming TTS:
async def llm_to_tts_pipeline(user_message: str):
"""Pipeline: Streaming LLM → Streaming TTS in tempo reale."""
# Fase 1: Accumula la risposta LLM per frase
sentence_buffer = ""
stream = client.responses.create(
model="gpt-5.6-luna",
input=[{"role": "user", "content": user_message}],
stream=True
)
for event in stream:
# Solo il testo della risposta deve essere parlato
if event.type == "response.output_text.delta":
sentence_buffer += event.delta
# Rileva la fine della frase
if sentence_buffer.rstrip().endswith((".", "!", "?")):
sentence = sentence_buffer.strip()
sentence_buffer = ""
# Fase 2: Invia questa frase allo streaming TTS
stream_tts_to_speaker(sentence)
# Elabora il buffer rimanente
if sentence_buffer.strip():
stream_tts_to_speaker(sentence_buffer.strip())
Punti chiave
- Lo streaming TTS riduce il TTFB a poche centinaia di millisecondi avviando la riproduzione prima del termine della generazione
- Il formato
pcmè ottimale per lo streaming: nessuna decodifica richiesta, riproduzione diretta - Un buffer di pre-caricamento di 2–3 blocchi previene le interruzioni all’inizio della riproduzione
- Il client asincrono è essenziale per i server che gestiscono più connessioni simultanee
- Combinare lo streaming LLM e lo streaming TTS consente di creare un agente vocale reattivo senza le API Realtime