Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Kašnjenje i optimizacija u stvarnom vremenu

Lekcija 17 od 18 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Kašnjenje i optimizacija u stvarnom vremenu
  2. Anatomija kašnjenja
  3. Optimizacija VAD detekcije
  4. Optimizacija sistemskih uputa
  5. Smanjenje mrežnog kašnjenja
  6. Optimizacija pozivanja funkcija
  7. Praćenje kašnjenja
  8. Ključne točke

Ažurirano 2. studenoga 2026. — Audio modeli. Nekoliko modela u ovom tečaju je zastarjelo: tts-1, tts-1-hd i gpt-4o-mini-tts prestat će s radom 6. siječnja 2027. (nasljednik: gpt-realtime-2.1-mini, za koji OpenAI TTS vodič navodi da nije podržan od strane /v1/audio/speech: migracija sinteze glasa prelazi na Realtime API); gpt-realtime, gpt-4o-realtime i stariji audio modeli 20. siječnja 2027. (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe i /v1/audio/translations 26. veljače 2027. (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Za full-duplex glas, GPT-Live 1 dostupan je u API-ju od 10. rujna 2026.

Ispravljeno 3. studenoga 2026. Trajanja dodijeljena svakom koraku („VAD 300-700 ms“, „mreža 20-100 ms“, „model 200-800 ms“) i pragovi percepcije („iznad 500 ms“) nisu imala izvore: OpenAI ne objavljuje takve brojke, pa te lekcija sada uči kako ih izmjeriti. Uputa za postavljanje poslužitelja „u istu regiju kao i OpenAI poslužitelji (US East)“ uklonjena je zbog nedostatka izvora. Dokumentirani dodaci: semantic_vad, WARP za ubrzavanje uspostave WebRTC sesije. Izvori: Detekcija glasovne aktivnosti · WebRTC s WARP-om · Optimizacija troškova.

Kašnjenje i optimizacija u stvarnom vremenu

Kašnjenje je neprijatelj broj jedan glasovnog agenta: tišina koja slijedi nakon kraja pitanja odmah je uočljiva na telefonu ili u aplikaciji. Ova lekcija detaljno opisuje izvore kašnjenja, kako ih izmjeriti i tehnike za njihovo smanjenje.

Anatomija kašnjenja

Ukupno kašnjenje glasovnog agenta zbroj je nekoliko komponenti:

VAD
Čekanje tišine koja završava okret (`silence_duration_ms`)
Mreža
Povratna putovanja između korisnika, tvog poslužitelja i API-ja
Model
Obrada konteksta, zatim prvi audio isječak

Ovisno o tvojoj arhitekturi, dodaj alate koje agent poziva i vrijeme postavljanja sesije. Nijedno od ovih trajanja nije fiksno: ovise o tvojim postavkama, duljini razgovora i mrežnom putu. Jedini način da saznaš gdje vrijeme odlazi je mjerenje svakog koraka, kako to čini monitor prikazan u nastavku.

Optimizacija VAD detekcije

Kod server_vad, odgovor ne može započeti prije nego što završi tišina definirana s silence_duration_ms: to je stoga izravna postavka za percipirano kašnjenje, koju treba uravnotežiti s rizikom prekidanja korisnika. Vrijednosti u nastavku su polazišne točke za testiranje, a ne OpenAI preporuke:

# Agresivna konfiguracija (brz odgovor, rizik od prekidanja korisnika)
fast_vad = {
    "type": "server_vad",
    "threshold": 0.6,           # Viši prag = manje lažno pozitivnih
    "prefix_padding_ms": 200,
    "silence_duration_ms": 400  # Brza reakcija
}

# Strpljiva konfiguracija (manje prekida, više kašnjenja)
patient_vad = {
    "type": "server_vad",
    "threshold": 0.4,
    "prefix_padding_ms": 400,
    "silence_duration_ms": 800
}

# Alternativa: semantički VAD, koji procjenjuje kraj rečenice na temelju riječi;
# eagerness "high" odgovara što prije, "low" dopušta korisniku da završi
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}

# Adaptivna konfiguracija na temelju konteksta
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
    }

Optimizacija sistemskih uputa

Sažete upute smanjuju kontekst koji treba obraditi. Također imaj na umu da Realtime API automatski primjenjuje keširanje promptova: stabilne upute i alati, postavljeni na vrh i nikada modificirani tijekom sesije, ponovno se koriste iz okreta u okret.

# Opširne upute (više tokena za obradu)
bad_instructions = """
Ti si inteligentan i kompetentan glasovni asistent koji radi
za Corsen AI, francusku tvrtku specijaliziranu za
umjetnu inteligenciju. Moraš odgovarati na korisnička pitanja
profesionalno, sažeto i na hrvatskom jeziku.
Imaš pristup raznim alatima za konzultiranje termina,
provjeru dostupnosti i izradu rezervacija.
Nemoj se ustručavati tražiti pojašnjenje ako je zahtjev nejasan.
"""

# Optimizirane upute (isti učinak, manje tokena)
good_instructions = """
Corsen AI glasovni asistent. Hrvatski, sažeto, profesionalno.
Koristi alate za termine i rezervacije.
Traži pojašnjenje ako je potrebno.
"""

Smanjenje mrežnog kašnjenja

Mjerenje povratnog puta (Round Trip)

Postavi svoj WebSocket relej što bliže svojim korisnicima i izmjeri put umjesto da ga pretpostavljaš. Jednostavan događaj, poput brisanja ulaznog međuspremnika, dovoljan je za mjerenje povratnog puta:

import time

async def measure_roundtrip(ws):
    """Mjeri mrežno kašnjenje prema Realtime API-ju."""
    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  # ignoriraj druge događaje koji stignu u međuvremenu
    roundtrip_ms = (time.monotonic() - start) * 1000
    print(f"Mrežno kašnjenje: {roundtrip_ms:.0f} ms")
    return roundtrip_ms

Keepalive i ponovno povezivanje

import asyncio
import websockets

async def robust_connection(api_key: str, max_retries: int = 5):
    """Robusna veza s automatskim ponovnim povezivanjem."""
    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 svakih 20s
                ping_timeout=10,       # Timeout pinga 10s
                close_timeout=5        # Timeout zatvaranja 5s
            ) as ws:
                retry_count = 0  # Resetiraj kod uspješne veze
                yield ws

        except websockets.exceptions.ConnectionClosed:
            retry_count += 1
            wait = min(2 ** retry_count, 30)
            print(f"Ponovno povezivanje za {wait}s...")
            await asyncio.sleep(wait)

Ponovno povezivanje otvara novu sesiju: prethodni razgovor više nije tu, a sesija ionako traje najviše 60 minuta. Zato vodi vlastitu evidenciju razmjena (transkripcije, rezultati alata) i ponovno ubaci bitno s conversation.item.create nakon ponovnog povezivanja.

Ubrzavanje postavljanja WebRTC-a: WARP

Na strani preglednika ili nativne aplikacije, OpenAI dokumentira WARP (WebRTC Abridged Roundtrip Protocol), koji smanjuje vrijeme uspostave WebRTC sesije kombiniranjem tri optimizacije transporta: DTLS 1.3, SPED i SNAP. To su nacrti IETF-a, podržani novijim verzijama libwebrtc; možeš omogućiti one koje tvoj klijent podržava, jednu po jednu. Vodič WebRTC s WARP-om detaljno opisuje konfiguraciju.

Optimizacija pozivanja funkcija

Pozivi funkcija dodaju kašnjenje. Optimiziraj njihovo izvršavanje:

import asyncio

async def execute_functions_parallel(function_calls: list) -> list:
    """Izvršava pozive funkcija paralelno."""
    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

# Keš za česte funkcije
from functools import lru_cache

@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
    """Kešira rezultate čestih zahtjeva."""
    # Upit bazi podataka ili API-ju
    return {"data": "..."}

Praćenje kašnjenja

Integriraj sustav mjerenja za identifikaciju uskih grla:

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)

Ključne točke

  • Ukupno kašnjenje zbraja VAD, mrežu, model i alate: izmjeri svaki korak, OpenAI ne objavljuje tipična trajanja
  • silence_duration_ms izravno kontrolira čekanje prije odgovora; semantic_vad i njegov eagerness su druga poluga
  • Sažete sistemske upute smanjuju vrijeme obrade modela
  • Paralelno izvršavanje poziva funkcija i keširanje smanjuju kašnjenje aplikacije
  • Sustav praćenja s TTFA (Time-to-First-Audio) ključan je za kontinuiranu optimizaciju