Salt la conținutul principal
Română— Alege o limbă
Meniu

Latență și optimizare în timp real

Lecția 17 din 18 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Latență și optimizare în timp real
  2. Anatomia latenței
  3. Optimizarea detectării VAD
  4. Optimizarea instrucțiunilor de sistem
  5. Reducerea latenței rețelei
  6. Optimizarea apelurilor de funcții
  7. Monitorizarea latenței
  8. Puncte cheie

Actualizat pe 2 noiembrie 2026 — Modele audio. Mai multe modele din acest curs sunt depreciate: tts-1, tts-1-hd și gpt-4o-mini-tts vor 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/translations la 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:

VAD
Așteptarea tăcerii care încheie turul (`silence_duration_ms`)
Rețea
Dus-întors între utilizator, serverul dumneavoastră și API
Model
Procesarea contextului, apoi primul chunk audio

Î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_ms controlează direct așteptarea înainte de răspuns; semantic_vad și eagerness să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ă