Késleltetés és valós idejű optimalizálás
Ezen az oldalon
Frissítve: 2026. november 2. – Hangmodellek. A tanfolyam több modellje elavult: a
tts-1,tts-1-hdés agpt-4o-mini-ttstámogatása 2027. január 6-án megszűnik (utód:gpt-realtime-2.1-mini, amelyet az OpenAI TTS útmutatója szerint a/v1/audio/speechnem támogat: a hangszintézis migrációja a Realtime API felé történik); agpt-realtime,gpt-4o-realtimeés a régi hangmodellek támogatása 2027. január 20-án szűnik meg (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5); awhisper-1,gpt-4o-transcribeés a/v1/audio/translationstámogatása 2027. február 26-án ér véget (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). A teljes duplex hangkommunikációhoz a GPT-Live 1 már 2026. szeptember 10. óta elérhető az API-ban.
Helyesbítve: 2026. november 3. Az egyes lépésekhez rendelt időtartamok („VAD 300–700 ms“, „hálózat 20–100 ms“, „modell 200–800 ms“) és az észlelési küszöbértékek („500 ms felett“) forrás nélkül maradtak: az OpenAI nem tesz közzé ilyen adatokat, ezért ez a lecke most arra tanít, hogyan mérd le ezeket. Az utasítást, miszerint a szerveredet az „OpenAI szerverekkel azonos régióba (US East)“ kell helyezned, forráshiány miatt eltávolítottuk. Dokumentált kiegészítések:
semantic_vad, WARP a WebRTC munkamenet-létesítés gyorsítására. Források: Voice activity detection · WebRTC with WARP · Cost optimization.
Késleltetés és valós idejű optimalizálás
A késleltetés a hangalapú ügynökök első számú ellensége: a kérdés végén beálló csendet azonnal észreveszik telefonon vagy alkalmazásban. Ez a lecke részletezi a késleltetés forrásait, a mérésük módját, valamint a csökkentésükre szolgáló technikákat.
A késleltetés anatómiája
Egy hangügynök teljes késleltetése több komponens összege:
Az architektúrádtól függően add hozzá az ügynök által hívott eszközök idejét és a munkamenet-beállítási időt. Ezen időtartamok egyike sem rögzített: a beállításaidtól, a beszélgetés hosszától és a hálózati útvonaltól függenek. Az egyetlen módja annak, hogy tudd, hol megy el az idő, ha minden lépést időzítesz, ahogy az alábbi monitor is teszi.
A VAD-észlelés optimalizálása
A server_vad használatakor a válasz nem indulhat el a silence_duration_ms által meghatározott csend vége előtt: ez tehát közvetlen beállítás az észlelt késleltetésre, amelyet egyensúlyba kell hozni a felhasználó félbeszakításának kockázatával. Az alábbi értékek kiindulópontok tesztelésre, nem OpenAI-ajánlások:
# Agresszív konfiguráció (gyors válasz, kockázat: felhasználó levágása)
fast_vad = {
"type": "server_vad",
"threshold": 0.6, # Magasabb küszöb = kevesebb téves pozitív
"prefix_padding_ms": 200,
"silence_duration_ms": 400 # Gyors reakció
}
# Türelmes konfiguráció (kevesebb megszakítás, nagyobb késleltetés)
patient_vad = {
"type": "server_vad",
"threshold": 0.4,
"prefix_padding_ms": 400,
"silence_duration_ms": 800
}
# Alternatíva: szemantikai VAD, amely szavak alapján ítéli meg a mondat végét;
# az "high" eagerness azonnal válaszol, a "low" megvárja, míg a felhasználó befejezi
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}
# Kontextus alapú adaptív konfiguráció
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
}
Rendszerutasítások optimalizálása
A tömör utasítások csökkentik a feldolgozandó kontextust. Ne feledd azt sem, hogy a Realtime API automatikusan alkalmazza a prompt-gyorsítótárazást: a stabil utasítások és eszközök, amelyeket a session elejére helyezel, és a munkamenet során soha nem módosítasz, fordulóról fordulóra újrahasznosításra kerülnek.
# Bőbeszédű utasítások (több token feldolgozása)
bad_instructions = """
Te egy intelligens és hozzáértő hangasszisztens vagy,
aki a Corsen AI-nak dolgozik, egy mesterséges intelligenciára
specializálódott francia cégnek. Profi módon, tömören
és franciául kell válaszolnod a felhasználók kérdéseire.
Hozzáférésed van különböző eszközökhöz időpontok lekérdezéséhez,
rendelkezésre állás ellenőrzéséhez és foglalások készítéséhez.
Ne habozz tisztázást kérni, ha a kérés nem egyértelmű.
"""
# Optimalizált utasítások (ugyanaz a hatás, kevesebb token)
good_instructions = """
Corsen AI hangasszisztens. Francia, tömör, professzionális.
Használd az eszközöket időpontokhoz és foglalásokhoz.
Kérj tisztázást, ha szükséges.
"""
Hálózati késleltetés csökkentése
Körút mérése
Helyezd a WebSocket közvetítődet (relay) a lehető legközelebb a felhasználóidhoz, és mérd le az útvonalat, ne pedig feltételezd azt. Egy egyszerű esemény, például a bemeneti puffer törlése, elegendő egy körút időzítéséhez:
import time
async def measure_roundtrip(ws):
"""Méri a hálózati késleltetést a Realtime API felé."""
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 # figyelmen kívül hagyja a közben érkező egyéb eseményeket
roundtrip_ms = (time.monotonic() - start) * 1000
print(f"Hálózati késleltetés: {roundtrip_ms:.0f} ms")
return roundtrip_ms
Keepalive és újracsatlakozás
import asyncio
import websockets
async def robust_connection(api_key: str, max_retries: int = 5):
"""Robusztus kapcsolat automatikus újracsatlakozással."""
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 minden 20 mp-ben
ping_timeout=10, # Ping időtúllépés 10 mp
close_timeout=5 # Zárás időtúllépés 5 mp
) as ws:
retry_count = 0 # Alaphelyzetbe állítás sikeres csatlakozás esetén
yield ws
except websockets.exceptions.ConnectionClosed:
retry_count += 1
wait = min(2 ** retry_count, 30)
print(f"Újracsatlakozás {wait} mp múlva...")
await asyncio.sleep(wait)
Egy újracsatlakozás egy új munkamenetet nyit meg: az előző beszélgetés már nincs ott, és egy munkamenet amúgy is maximum 60 percig tart. Ezért tartsd saját magadnál a váltások rekordját (átiratok, eszközeredmények), és újracsatlakozás után a conversation.item.create segítségével injektáld vissza a lényeges elemeket.
WebRTC-beállítás gyorsítása: WARP
Böngésző vagy natív alkalmazás oldalán az OpenAI dokumentálja a WARP-ot (WebRTC Abridged Roundtrip Protocol), amely három transzportoptimalizálás kombinálásával csökkenti a WebRTC munkamenet-létesítési idejét: DTLS 1.3, SPED és SNAP. Ezek IETF-tervezetek, amelyeket a libwebrtc legújabb verziói támogatnak; engedélyezheted azokat, amelyeket a kliensed támogat, egyesével. A WebRTC with WARP útmutató részletezi a konfigurációt.
Függvényhívások optimalizálása
A függvényhívások késleltetést adnak hozzá. Optimalizáld a végrehajtásukat:
import asyncio
async def execute_functions_parallel(function_calls: list) -> list:
"""Párhuzamosan hajtja végre a függvényhívásokat."""
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
# Gyorsítótár gyakori függvényekhez
from functools import lru_cache
@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
"""Gyorsítótárazza a gyakori kérések eredményeit."""
# Adatbázis vagy API lekérdezés
return {"data": "..."}
Késleltetés-monitorozás
Integrálj egy mérőrendszert a szűk keresztmetszetek azonosításához:
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)
Főbb megállapítások
- A teljes késleltetés a VAD, a hálózat, a modell és az eszközök összegéből adódik: mérd le minden lépést, az OpenAI nem tesz közzé tipikus időtartamokat
- A
silence_duration_msközvetlenül szabályozza a válasz előtti várakozást; asemantic_vadés annakeagernessparamétere a másik szabályozókar - A tömör rendszerutasítások csökkentik a modell feldolgozási idejét
- A függvényhívások párhuzamos végrehajtása és gyorsítótárazása csökkenti az alkalmazás késleltetését
- A TTFA-val (Time-to-First-Audio) rendelkező monitorozó rendszer elengedhetetlen a folyamatos optimalizáláshoz