Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Latenza e ottimizzazione in tempo reale

Lezione 17 di 18 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Latenza e ottimizzazione in tempo reale
  2. Anatomia della latenza
  3. Ottimizzazione del rilevamento VAD
  4. Ottimizzazione delle istruzioni di sistema
  5. Riduzione della latenza di rete
  6. Ottimizzazione della chiamata di funzioni
  7. Monitoraggio della latenza
  8. Punti chiave

Aggiornato il 2 novembre 2026 — Modelli audio. Diversi modelli in questo corso sono deprecati: tts-1, tts-1-hd e gpt-4o-mini-tts cesseranno 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-realtime e 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-transcribe e /v1/audio/translations il 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:

VAD
Attesa del silenzio che conclude il turno (`silence_duration_ms`)
Rete
Andate e ritorni tra l'utente, il tuo server e le API
Modello
Elaborazione del contesto, poi primo chunk audio

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_ms controlla direttamente l’attesa prima della risposta; semantic_vad e il suo eagerness sono 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