Latență și optimizare în timp real
Pe această pagină
Actualizat pe 2 noiembrie 2026 — Modele audio. Mai multe modele din acest curs sunt depreciate:
tts-1,tts-1-hdșigpt-4o-mini-ttsvor fi oprite la 6 ianuarie 2027 (succesor:gpt-realtime-2.1-mini, pe care ghidul OpenAI TTS precizează că nu este suportat de/v1/audio/speech: migrarea sintezei vocale se face către API-ul Realtime);gpt-realtime,gpt-4o-realtimeși modelele audio legacy la 20 ianuarie 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeși/v1/audio/translationsla 26 februarie 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pentru voce full-duplex, GPT-Live 1 este disponibil în API din 10 septembrie 2026.
Corectat pe 3 noiembrie 2026. Duratele atribuite fiecărui pas („VAD 300-700 ms“, „rețea 20-100 ms“, „model 200-800 ms“) și pragurile de percepție („peste 500 ms“) nu aveau surse: OpenAI nu publică astfel de cifre, iar lecția vă învață acum cum să le măsurați. Instrucțiunea de a plasa serverul „în aceeași regiune cu serverele OpenAI (US East)“ a fost eliminată din lipsă de surse. Adăugări documentate:
semantic_vad, WARP pentru accelerarea stabilirii sesiunii WebRTC. Surse: Detectarea activității vocale · WebRTC cu WARP · Optimizarea costurilor.
Latență și optimizare în timp real
Latența este inamicul numărul unu al unui agent vocal: tăcerea care urmează sfârșitului unei întrebări este imediat observabilă la telefon sau într-o aplicație. Această lecție detaliază sursele latenței, modul de măsurare a acestora și tehnicile de reducere.
Anatomia latenței
Latența totală a unui agent vocal este suma mai multor componente:
În funcție de arhitectura dumneavoastră, adăugați instrumentele pe care agentul le apelează și timpul de configurare a sesiunii. Niciuna dintre aceste durate nu este fixă: ele depind de setările dumneavoastră, de lungimea conversației și de ruta rețelei. Singura modalitate de a ști unde se consumă timpul este cronometrarea fiecărui pas, așa cum face monitorul prezentat mai jos.
Optimizarea detectării VAD
Cu server_vad, răspunsul nu poate începe înainte ca tăcerea definită de silence_duration_ms să se încheie: aceasta este deci o setare directă pentru latența percepută, care trebuie echilibrată cu riscul de a întrerupe utilizatorul. Valorile de mai jos sunt puncte de plecare pentru testare, nu recomandări OpenAI:
# Configurație agresivă (răspuns rapid, risc de întrerupere a utilizatorului)
fast_vad = {
"type": "server_vad",
"threshold": 0.6, # Prag mai ridicat = mai puține fals pozitive
"prefix_padding_ms": 200,
"silence_duration_ms": 400 # Reacție rapidă
}
# Configurație pacientă (mai puține întreruperi, latență mai mare)
patient_vad = {
"type": "server_vad",
"threshold": 0.4,
"prefix_padding_ms": 400,
"silence_duration_ms": 800
}
# Alternativă: VAD semantic, care judecă sfârșitul propoziției pe baza cuvintelor;
# eagerness "high" răspunde cât mai repede, "low" lasă utilizatorul să termine
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}
# Configurație adaptivă bazată pe context
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
}
Optimizarea instrucțiunilor de sistem
Instrucțiunile concise reduc contextul de procesat. Rețineți, de asemenea, că API-ul Realtime aplică automat cache-ul pentru prompturi: instrucțiunile și instrumentele stabile, plasate la început și nemodificate durante unei sesiuni, sunt reutilizate din tur în tur.
# Instrucțiuni verbose (mai mulți tokeni de procesat)
bad_instructions = """
Ești un asistent vocal inteligent și competent care lucrează
pentru Corsen AI, o companie franceză specializată în
inteligență artificială. Trebuie să răspunzi întrebărilor utilizatorului
profesional, concis și în franceză.
Ai acces la diverse instrumente pentru a consulta programări,
a verifica disponibilitatea și a face rezervări.
Nu ezita să ceri clarificări dacă cererea este neclară.
"""
# Instrucțiuni optimizate (același efect, mai puțini tokeni)
good_instructions = """
Asistent vocal Corsen AI. Franceză, concis, profesionist.
Folosește instrumentele pentru programări și rezervări.
Cere clarificări dacă este nevoie.
"""
Reducerea latenței rețelei
Măsurarea dus-întors (Round Trip)
Plasați releul WebSocket cât mai aproape posibil de utilizatorii dumneavoastră și măsurați ruta în loc să o presupuneți. Un eveniment simplu, precum golirea buffer-ului de intrare, este suficient pentru a cronometra un dus-întors:
import time
async def measure_roundtrip(ws):
"""Măsoară latența rețelei către API-ul 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 # ignoră alte evenimente care sosesc între timp
roundtrip_ms = (time.monotonic() - start) * 1000
print(f"Latență rețea: {roundtrip_ms:.0f} ms")
return roundtrip_ms
Keepalive și reconectare
import asyncio
import websockets
async def robust_connection(api_key: str, max_retries: int = 5):
"""Conexiune robustă cu reconectare automată."""
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 la fiecare 20s
ping_timeout=10, # Timeout ping 10s
close_timeout=5 # Timeout închidere 5s
) as ws:
retry_count = 0 # Resetare la conexiune reușită
yield ws
except websockets.exceptions.ConnectionClosed:
retry_count += 1
wait = min(2 ** retry_count, 30)
print(f"Reconectare în {wait}s...")
await asyncio.sleep(wait)
O reconectare deschide o nouă sesiune: conversația anterioară nu mai este acolo, iar o sesiune durează oricum maximum 60 de minute. Așadar, păstrați propria evidență a schimburilor (transcrieri, rezultate ale instrumentelor) și reinjectați esențialul cu conversation.item.create după o reconectare.
Accelerarea configurării WebRTC: WARP
În partea de browser sau aplicație nativă, OpenAI documentează WARP (WebRTC Abridged Roundtrip Protocol), care reduce timpul de stabilire a sesiunii WebRTC combinând trei optimizări de transport: DTLS 1.3, SPED și SNAP. Acestea sunt drafturi IETF, suportate de versiunile recente ale libwebrtc; puteți activa cele pe care clientul dumneavoastră le suportă, unul câte unul. Ghidul WebRTC cu WARP detaliază configurarea.
Optimizarea apelurilor de funcții
Apelurile de funcții adaugă latență. Optimați execuția lor:
import asyncio
async def execute_functions_parallel(function_calls: list) -> list:
"""Execută apelurile de funcții în paralel."""
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 pentru funcțiile frecvente
from functools import lru_cache
@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
"""Cachează rezultatele cererilor frecvente."""
# Interogare bază de date sau API
return {"data": "..."}
Monitorizarea latenței
Integrați un sistem de măsurare pentru a identifica gâtuirile:
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)
Puncte cheie
- Latența totală însumează VAD, rețea, model și instrumente: măsurați fiecare pas, OpenAI nu publică durate tipice
silence_duration_mscontrolează direct așteptarea înainte de răspuns;semantic_vadșieagernesssău sunt cealaltă pârghie- Instrucțiunile de sistem concise reduc timpul de procesare al modelului
- Execuția paralelă a apelurilor de funcții și cache-ul reduc latența aplicației
- Un sistem de monitorizare cu TTFA (Time-to-First-Audio) este esențial pentru optimizarea continuă