Kašnjenje i optimizacija u stvarnom vremenu
Na ovoj stranici
Ažurirano 2. studenoga 2026. — Audio modeli. Nekoliko modela u ovom tečaju je zastarjelo:
tts-1,tts-1-hdigpt-4o-mini-ttsprestat ć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-realtimei stariji audio modeli 20. siječnja 2027. (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribei/v1/audio/translations26. 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:
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_msizravno kontrolira čekanje prije odgovora;semantic_vadi njegoveagernesssu 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