Latencia a optimalizácia v reálnom čase
Na tejto strane
Aktualizované 2. novembra 2026 — Zvukové modely. Niekoľko modelov v tomto kurze je zastaraných:
tts-1,tts-1-hdagpt-4o-mini-ttsprestanú fungovať 6. januára 2027 (nástupca:gpt-realtime-2.1-mini, ktorý podľa príručky OpenAI TTS nie je podporovaný rozhraním/v1/audio/speech: syntéza hlasu sa presúva do Realtime API);gpt-realtime,gpt-4o-realtimea staršie zvukové modely 20. januára 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribea/v1/audio/translations26. februára 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pre plno duplexný hlas je GPT-Live 1 dostupné v API od 10. septembra 2026.
Opravené 3. novembra 2026. Dĺžky priradené jednotlivým krokom („VAD 300 – 700 ms“, „sieť 20 – 100 ms“, „model 200 – 800 ms“) a prahy vnímania („nad 500 ms“) nemali zdroje: OpenAI takéto údaje nezverejňuje a táto lekcia ťa teraz naučí, ako ich merať. Pokyn umiestniť server „do rovnakej regiónu ako servery OpenAI (US East)“ bol odstránený kvôli chýbajúcim zdrojom. Dokumentované doplnky:
semantic_vad, WARP na urýchlenie nadväzovania relácií WebRTC. Zdroje: Detekcia hlasovej aktivity · WebRTC s WARP · Optimalizácia nákladov.
Latencia a optimalizácia v reálnom čase
Latencia je nepriateľ číslo jedna pre hlasového agenta: ticho nasledujúce po skončení otázky je okamžite badateľné telefónne alebo v aplikácii. Táto lekcia podrobne opisuje zdroje latencie, spôsob ich merania a techniky na ich zníženie.
Anatómia latencie
Celková latencia hlasového agenta je súčtom niekoľkých zložiek:
V závislosti od tvojej architektúry pripočítaj čas na volanie nástrojov, ktoré agent používa, a čas na nastavenie relácie. Žiadna z týchto dĺžok nie je pevná: závisia od tvojich nastavení, dĺžky konverzácie a sieťovej cesty. Jediný spôsob, ako zistiť, kam sa čas míňa, je merať každý krok, čo robí nižšie uvedený monitor.
Optimalizácia detekcie VAD
Pri použití server_vad nemôže odpoveď začať skôr, než skončí ticho definované parametrom silence_duration_ms: ide teda o priame nastavenie vnímanej latencie, ktoré treba vyvážiť proti riziku prerušenia používateľa. Nižšie uvedené hodnoty sú východiskové body na testovanie, nie odporúčania OpenAI:
# Agresívna konfigurácia (rýchla odpoveď, riziko prerušenia používateľa)
fast_vad = {
"type": "server_vad",
"threshold": 0.6, # Vyšší prah = menej falošných pozitív
"prefix_padding_ms": 200,
"silence_duration_ms": 400 # Rýchla reakcia
}
# Trpezlivá konfigurácia (menej prerušení, väčšia latencia)
patient_vad = {
"type": "server_vad",
"threshold": 0.4,
"prefix_padding_ms": 400,
"silence_duration_ms": 800
}
# Alternatíva: sémantický VAD, ktorý hodnotí koniec vety na základe slov;
# hodnota "high" reaguje čo najskôr, "low" nechá používateľa dokončiť vetu
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}
# Adaptívna konfigurácia podľa kontextu
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
}
Optimalizácia systémových inštrukcií
Stručné inštrukcie znižujú kontext, ktorý treba spracovať. Pamätaj tiež, že Realtime API automaticky aplikuje ukladanie promptov do vyrovnávacej pamäte: stabilné inštrukcie a nástroje, umiestnené na začiatku a počas relácie nezmenené, sa opakovane využívajú od ťahu k ťahu.
# Rozvláčne inštrukcie (viac tokenov na spracovanie)
bad_instructions = """
Si inteligentný a kompetentný hlasový asistent pracujúci
pre spoločnosť Corsen AI, francúzsku firmu špecializujúcu sa na
umelú inteligenciu. Musíš odpovedať na otázky používateľov
profesionálne, stručne a vo francúzštine.
Máš prístup k rôznym nástrojom na konzultáciu termínov,
kontrolu dostupnosti a vytváranie rezervácií.
Neváhaj požiadať o objasnenie, ak je požiadavka nejasná.
"""
# Optimalizované inštrukcie (rovnaký efekt, menej tokenov)
good_instructions = """
Hlasový asistent Corsen AI. Francúzština, stručnosť, profesionalita.
Používaj nástroje na termíny a rezervácie.
V prípade potreby požiadaj o objasnenie.
"""
Znižovanie sieťovej latencie
Meranie cesty tam a späť
Umiestni svoje WebSocket relé čo najbližšie k svojim používateľom a meraj cestu, namiesto toho, aby si ju odhadoval. Na načasovanie cesty tam a späť stačí jednoduchá udalosť, ako je vyčistenie vstupnej vyrovnávacej pamäte:
import time
async def measure_roundtrip(ws):
"""Meria sieťovú latenciu voči Realtime API."""
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 # ignorovať ostatné udalosti prichádzajúce medzitým
roundtrip_ms = (time.monotonic() - start) * 1000
print(f"Sieťová latencia: {roundtrip_ms:.0f} ms")
return roundtrip_ms
Keepalive a opätovné pripojenie
import asyncio
import websockets
async def robust_connection(api_key: str, max_retries: int = 5):
"""Robustné pripojenie s automatickým opätovným pripojením."""
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 každých 20 s
ping_timeout=10, # Časový limit pingu 10 s
close_timeout=5 # Časový limit uzavretia 5 s
) as ws:
retry_count = 0 # Reset pri úspešnom pripojení
yield ws
except websockets.exceptions.ConnectionClosed:
retry_count += 1
wait = min(2 ** retry_count, 30)
print(f"Opätovné pripojenie o {wait} s...")
await asyncio.sleep(wait)
Opätovné pripojenie otvára novú reláciu: predchádzajúca konverzácia už nie je k dispozícii a relácia aj tak trvá maximálne 60 minút. Preto si vedi vlastný záznam výmen (prepisy, výsledky nástrojov) a po opätovnom pripojení znovu vlož podstatné časti pomocou conversation.item.create.
Urýchlenie nastavenia WebRTC: WARP
Na strane prehliadača alebo natívnej aplikácie OpenAI dokumentuje WARP (WebRTC Abridged Roundtrip Protocol), ktorý znižuje čas nadväzovania relácie WebRTC kombináciou troch optimalizácií transportu: DTLS 1.3, SPED a SNAP. Ide o návrhy IETF, podporované najnovšími verziami libwebrtc; môžeš povoliť tie, ktoré tvoj klient podporuje, postupne jeden po druhom. Príručka WebRTC s WARP podrobne opisuje konfiguráciu.
Optimalizácia volania funkcií
Volania funkcií pridávajú latenciu. Optimalizuj ich vykonávanie:
import asyncio
async def execute_functions_parallel(function_calls: list) -> list:
"""Vykonáva volania funkcií paralelne."""
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
# Vyrovnávacia pamäť pre časté funkcie
from functools import lru_cache
@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
"""Ukladá do vyrovnávacej pamäte výsledky častých požiadaviek."""
# Dotaz do databázy alebo API
return {"data": "..."}
Monitorovanie latencie
Integruj systém merania na identifikáciu úzkych hrdiel:
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)
Kľúčové poznatky
- Celková latencia zahŕňa VAD, sieť, model a nástroje: meraj každý krok, OpenAI nezverejňuje typické dĺžky
silence_duration_mspriamo riadi čakanie pred odpoveďou;semantic_vada jeho parametereagernesssú ďalšou pákou- Stručné systémové inštrukcie znižujú čas spracovania modelom
- Paralelné vykonávanie volaní funkcií a ukladanie do vyrovnávacej pamäte znižujú latenciu aplikácie
- Monitorovací systém s TTFA (Time-to-First-Audio) je nevyhnutný pre priebežnú optimalizáciu