Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Latencia a optimalizácia v reálnom čase

Lekcia 17 z 18 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Latencia a optimalizácia v reálnom čase
  2. Anatómia latencie
  3. Optimalizácia detekcie VAD
  4. Optimalizácia systémových inštrukcií
  5. Znižovanie sieťovej latencie
  6. Optimalizácia volania funkcií
  7. Monitorovanie latencie
  8. Kľúčové poznatky

Aktualizované 2. novembra 2026 — Zvukové modely. Niekoľko modelov v tomto kurze je zastaraných: tts-1, tts-1-hd a gpt-4o-mini-tts prestanú 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-realtime a 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-transcribe a /v1/audio/translations 26. 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:

VAD
Čakanie na ticho, ktoré ukončí ťah (`silence_duration_ms`)
Sieť
Cesty tam a späť medzi používateľom, tvojím serverom a API
Model
Spracovanie kontextu, potom prvý zvukový chunk

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_ms priamo riadi čakanie pred odpoveďou; semantic_vad a jeho parameter eagerness sú ď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