Latenza e ottimizzazione in tempo reale
In questa pagina
Aggiornato il 2 novembre 2026 — Modelli audio. Diversi modelli in questo corso sono deprecati:
tts-1,tts-1-hdegpt-4o-mini-ttscesseranno di funzionare il 6 gennaio 2027 (successore:gpt-realtime-2.1-mini, che la guida TTS di OpenAI indica come 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.
Corretto il 3 novembre 2026. Le durate assegnate a ogni fase (“VAD 300-700 ms”, “rete 20-100 ms”, “modello 200-800 ms”) e le soglie di percezione (“oltre 500 ms”) mancavano di fonti: OpenAI non pubblica tali cifre e questa lezione ti insegna ora come misurarle. È stata rimossa l’istruzione di posizionare il tuo server “nella stessa regione dei server OpenAI (US East)” per mancanza di fonti. Aggiunte documentate:
semantic_vad, WARP per accelerare l’avvio della sessione WebRTC. Fonti: Rilevamento attività vocale · WebRTC con WARP · Ottimizzazione dei costi.
Latenza e ottimizzazione in tempo reale
La latenza è il nemico numero uno di un agente vocale: il silenzio che segue la fine di una domanda è immediatamente percepibile al telefono o in un’applicazione. Questa lezione dettaglia le fonti della latenza, come misurarle e le tecniche per ridurle.
Anatomia della latenza
La latenza totale di un agente vocale è la somma di diversi componenti:
A seconda della tua architettura, aggiungi gli strumenti che l’agente chiama e il tempo di configurazione della sessione. Nessuna di queste durate è fissa: dipendono dalle tue impostazioni, dalla lunghezza della conversazione e dal percorso di rete. L’unico modo per sapere dove va il tempo è cronometrare ogni fase, come fa il monitor presentato di seguito.
Ottimizzazione del rilevamento VAD
Con server_vad, la risposta non può iniziare prima che termini il silenzio definito da silence_duration_ms: questa è quindi un’impostazione diretta per la latenza percepita, da bilanciare con il rischio di interrompere l’utente. I valori seguenti sono punti di partenza da testare, non raccomandazioni di OpenAI:
# Configurazione aggressiva (risposta veloce, rischio di interrompere l'utente)
fast_vad = {
"type": "server_vad",
"threshold": 0.6, # Soglia più alta = meno falsi positivi
"prefix_padding_ms": 200,
"silence_duration_ms": 400 # Reazione veloce
}
# Configurazione paziente (meno interruzioni, più latenza)
patient_vad = {
"type": "server_vad",
"threshold": 0.4,
"prefix_padding_ms": 400,
"silence_duration_ms": 800
}
# Alternativa: VAD semantico, che giudica la fine della frase in base alle parole;
# eagerness "high" risponde il prima possibile, "low" lascia finire l'utente
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}
# Configurazione adattiva basata sul contesto
def get_vad_config(context: str) -> dict:
configs = {
"menu_ivr": {"threshold": 0.6, "silence_duration_ms": 400},
"conversation": {"threshold": 0.5, "silence_duration_ms": 600},
"dictation": {"threshold": 0.3, "silence_duration_ms": 1200},
}
config = configs.get(context, configs["conversation"])
return {
"type": "server_vad",
"prefix_padding_ms": 300,
**config
}
Ottimizzazione delle istruzioni di sistema
Istruzioni concise riducono il contesto da elaborare. Ricorda inoltre che le API Realtime applicano automaticamente la cache dei prompt: istruzioni e strumenti stabili, posizionati all’inizio e mai modificati durante una sessione, vengono riutilizzati da un turno all’altro.
# Istruzioni verbose (più token da elaborare)
bad_instructions = """
Sei un assistente vocale intelligente e competente che lavora
per Corsen AI, un'azienda francese specializzata in
intelligenza artificiale. Devi rispondere alle domande dell'utente
in modo professionale, conciso e in francese.
Hai accesso a vari strumenti per consultare appuntamenti,
verificare la disponibilità ed effettuare prenotazioni.
Non esitare a chiedere chiarimenti se la richiesta non è chiara.
"""
# Istruzioni ottimizzate (stesso effetto, meno token)
good_instructions = """
Assistente vocale Corsen AI. Francese, conciso, professionale.
Usa gli strumenti per appuntamenti e prenotazioni.
Chiedi chiarimenti se necessario.
"""
Riduzione della latenza di rete
Misurazione dell’andata e ritorno
Posiziona il tuo relay WebSocket il più vicino possibile ai tuoi utenti e misura il percorso invece di supporlo. Un semplice evento, come la pulizia del buffer di input, è sufficiente per cronometrare un andata e ritorno:
import time
async def measure_roundtrip(ws):
"""Misura la latenza di rete verso le API Realtime."""
start = time.monotonic()
await ws.send(json.dumps({"type": "input_audio_buffer.clear"}))
while json.loads(await ws.recv())["type"] != "input_audio_buffer.cleared":
pass # ignora altri eventi che arrivano nel frattempo
roundtrip_ms = (time.monotonic() - start) * 1000
print(f"Latenza di rete: {roundtrip_ms:.0f} ms")
return roundtrip_ms
Keepalive e riconnessione
import asyncio
import websockets
async def robust_connection(api_key: str, max_retries: int = 5):
"""Connessione robusta con riconnessione automatica."""
retry_count = 0
while retry_count < max_retries:
try:
async with websockets.connect(
REALTIME_URL,
additional_headers={
"Authorization": f"Bearer {api_key}"
},
ping_interval=20, # Ping ogni 20s
ping_timeout=10, # Timeout ping 10s
close_timeout=5 # Timeout chiusura 5s
) as ws:
retry_count = 0 # Reset in caso di connessione riuscita
yield ws
except websockets.exceptions.ConnectionClosed:
retry_count += 1
wait = min(2 ** retry_count, 30)
print(f"Riconnessione tra {wait}s...")
await asyncio.sleep(wait)
Una riconnessione apre una nuova sessione: la conversazione precedente non è più presente e una sessione dura al massimo 60 minuti. Quindi mantieni il tuo registro degli scambi (trascrizioni, risultati degli strumenti) e reinietta l’essenziale con conversation.item.create dopo una riconnessione.
Accelerazione della configurazione WebRTC: WARP
Lato browser o app nativa, OpenAI documenta WARP (WebRTC Abridged Roundtrip Protocol), che riduce il tempo di avvio della sessione WebRTC combinando tre ottimizzazioni del trasporto: DTLS 1.3, SPED e SNAP. Si tratta di bozze IETF, supportate dalle versioni recenti di libwebrtc; puoi abilitare quelle supportate dal tuo client, una per una. La guida WebRTC con WARP dettaglia la configurazione.
Ottimizzazione della chiamata di funzioni
Le chiamate di funzione aggiungono latenza. Ottimizzane l’esecuzione:
import asyncio
async def execute_functions_parallel(function_calls: list) -> list:
"""Esegue le chiamate di funzione in parallelo."""
tasks = []
for call in function_calls:
task = execute_single_function(call["name"], call["arguments"])
tasks.append(task)
results = await asyncio.gather(*tasks, return_exceptions=True)
return results
# Cache per funzioni frequenti
from functools import lru_cache
@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
"""Mette in cache i risultati delle richieste frequenti."""
# Query al database o alle API
return {"data": "..."}
Monitoraggio della latenza
Integra un sistema di misurazione per identificare i colli di bottiglia:
import time
from dataclasses import dataclass, field
@dataclass
class LatencyMetrics:
speech_end_time: float = 0
response_start_time: float = 0
first_audio_time: float = 0
response_complete_time: float = 0
function_call_times: list = field(default_factory=list)
@property
def time_to_first_audio(self) -> float:
if self.speech_end_time and self.first_audio_time:
return (self.first_audio_time - self.speech_end_time) * 1000
return 0
@property
def total_response_time(self) -> float:
if self.speech_end_time and self.response_complete_time:
return (self.response_complete_time - self.speech_end_time) * 1000
return 0
def report(self) -> dict:
return {
"ttfa_ms": round(self.time_to_first_audio),
"total_ms": round(self.total_response_time),
"function_calls_ms": [round(t * 1000) for t in self.function_call_times]
}
class LatencyTracker:
def __init__(self):
self.current = LatencyMetrics()
self.history = []
def on_event(self, event_type: str):
now = time.time()
if event_type == "input_audio_buffer.speech_stopped":
self.current.speech_end_time = now
elif event_type == "response.output_audio.delta":
if not self.current.first_audio_time:
self.current.first_audio_time = now
elif event_type == "response.done":
self.current.response_complete_time = now
self.history.append(self.current.report())
self.current = LatencyMetrics()
def average_ttfa(self) -> float:
if not self.history:
return 0
return sum(h["ttfa_ms"] for h in self.history) / len(self.history)
Punti chiave
- La latenza totale somma VAD, rete, modello e strumenti: misura ogni fase, OpenAI non pubblica durate tipiche
silence_duration_mscontrolla direttamente l’attesa prima della risposta;semantic_vade il suoeagernesssono l’altra leva- Istruzioni di sistema concise riducono il tempo di elaborazione del modello
- L’esecuzione parallela delle chiamate di funzione e la cache riducono la latenza dell’applicazione
- Un sistema di monitoraggio con TTFA (Time-to-First-Audio) è essenziale per l’ottimizzazione continua