Latens og optimering i realtid
På denne side
Opdateret 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset:
tts-1,tts-1-hdoggpt-4o-mini-ttsstopper den 6. januar 2027 (efterfølger:gpt-realtime-2.1-mini, som OpenAI TTS-guiden angiver ikke understøttes af/v1/audio/speech: migration af talesyntese flytter til Realtime API);gpt-realtime,gpt-4o-realtimeog ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeog/v1/audio/translationsden 26. februar 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Til fuld-duplex tale har GPT-Live 1 været tilgængelig i API’en siden 10. september 2026.
Korrigeret 3. november 2026. Varighederne tildelt hvert trin (“VAD 300-700 ms”, “netværk 20-100 ms”, “model 200-800 ms”) og perceptionstærskler (“over 500 ms”) manglede kilder: OpenAI offentliggør ikke sådanne tal, og lektionen lærer dig nu, hvordan du måler dem. Instruktionen om at placere din server “i samme region som OpenAI-servere (US East)” blev fjernet på grund af manglende kildehenvisning. Dokumenterede tilføjelser:
semantic_vad, WARP til at accelerere WebRTC-sessionsetablering. Kilder: Voice activity detection · WebRTC with WARP · Cost optimization.
Latens og optimering i realtid
Latens er voice agentens værste fjende: stilheden efter slutningen på et spørgsmål bemærkes øjeblikkeligt i telefonen eller i en applikation. Denne lektion gennemgår kilderne til latens, hvordan du måler dem, og teknikker til at reducere dem.
Anatomien bag latens
Den samlede latens for en voice agent er summen af flere komponenter:
Afhængigt af din arkitektur skal du lægge de værktøjer, som agenten kalder, og sessionens opsætningstid til. Ingen af disse varigheder er faste: de afhænger af dine indstillinger, samtalelængde og netværksrute. Den eneste måde at vide, hvor tiden går, er at tage tid på hvert trin, præcis som monitoren nedenfor gør.
Optimering af VAD-detektering
Med server_vad kan svaret ikke starte, før stilheden defineret af silence_duration_ms er slut: dette er derfor en direkte indstilling for den oplevede latens, som skal afvejes mod risikoen for at afbryde brugeren. Værdierne nedenfor er udgangspunkter til test, ikke OpenAI-anbefalinger:
# Aggressiv konfiguration (hurtigt svar, risiko for at afbryde bruger)
fast_vad = {
"type": "server_vad",
"threshold": 0.6, # Højere tærskel = færre falske positiver
"prefix_padding_ms": 200,
"silence_duration_ms": 400 # Hurtig reaktion
}
# Tålmodig konfiguration (færre afbrydelser, mere latens)
patient_vad = {
"type": "server_vad",
"threshold": 0.4,
"prefix_padding_ms": 400,
"silence_duration_ms": 800
}
# Alternativ: semantisk VAD, der bedømmer sætningsafslutning baseret på ord;
# eagerness "high" svarer ASAP, "low" lader brugeren gøre færdig
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}
# Adaptiv konfiguration baseret på kontekst
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
}
Optimering af systeminstruktioner
Koncise instruktioner reducerer den kontekst, der skal behandles. Husk også, at Realtime API automatisk anvender prompt-caching: stabile instruktioner og værktøjer, placeret øverst og aldrig ændret under en session, genbruges fra tur til tur.
# Omstændelige instruktioner (flere tokens at behandle)
bad_instructions = """
Du er en intelligent og kompetent voice-assistent, der arbejder
for Corsen AI, et fransk firma specialiseret i
kunstig intelligens. Du skal besvare brugerspørgsmål
professionelt, koncist og på fransk.
Du har adgang til forskellige værktøjer til at konsultere aftaler,
tjekke tilgængelighed og foretage reservationer.
Tøv ikke med at bede om afklaring, hvis anmodningen er uklar.
"""
# Optimerede instruktioner (samme effekt, færre tokens)
good_instructions = """
Corsen AI voice-assistent. Fransk, koncis, professionel.
Brug værktøjer til aftaler og reservationer.
Bed om afklaring ved behov.
"""
Reducering af netværkslatens
Måling af rundtur
Placer dit WebSocket-relæ så tæt på dine brugere som muligt og mål ruten i stedet for at gætte. En simpel begivenhed, som at rydde input-bufferen, er nok til at tage tid på en rundtur:
import time
async def measure_roundtrip(ws):
"""Måler netværkslatens til 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 # ignorer andre begivenheder, der ankommer imellem
roundtrip_ms = (time.monotonic() - start) * 1000
print(f"Netværkslatens: {roundtrip_ms:.0f} ms")
return roundtrip_ms
Keepalive og genforbindelse
import asyncio
import websockets
async def robust_connection(api_key: str, max_retries: int = 5):
"""Robust forbindelse med automatisk genforbindelse."""
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 hvert 20. sekund
ping_timeout=10, # Ping-timeout 10 sekunder
close_timeout=5 # Luk-timeout 5 sekunder
) as ws:
retry_count = 0 # Nulstil ved succesfuld forbindelse
yield ws
except websockets.exceptions.ConnectionClosed:
retry_count += 1
wait = min(2 ** retry_count, 30)
print(f"Genforbinder om {wait}s...")
await asyncio.sleep(wait)
En genforbindelse åbner en ny session: den tidligere samtale er væk, og en session varer alligevel højst 60 minutter. Så hold din egen registrering af udvekslinger (transskriptioner, værktøjsresultater) og injicer det vigtigste igen med conversation.item.create efter en genforbindelse.
Acceleration af WebRTC-opsætning: WARP
På browser- eller native app-siden dokumenterer OpenAI WARP (WebRTC Abridged Roundtrip Protocol), som reducerer tiden til etablering af WebRTC-sessioner ved at kombinere tre transportoptimeringer: DTLS 1.3, SPED og SNAP. Dette er IETF-udkast, understøttet af nyere versioner af libwebrtc; du kan aktivere dem, din klient understøtter, én efter én. Guiden WebRTC with WARP beskriver konfigurationen i detaljer.
Optimering af funktionskald
Funktionskald tilføjer latens. Optimer deres udførelse:
import asyncio
async def execute_functions_parallel(function_calls: list) -> list:
"""Udfører funktionskald parallelt."""
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
# Cache til hyppige funktioner
from functools import lru_cache
@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
"""Cacher resultater af hyppige forespørgsler."""
# Database- eller API-forespørgsel
return {"data": "..."}
Latensovervågning
Integrer et målesystem for at identificere flaskehalse:
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)
Vigtige pointer
- Samlet latens lægger VAD, netværk, model og værktøjer sammen: mål hvert trin, OpenAI offentliggør ikke typiske varigheder
silence_duration_msstyrer direkte ventetiden før svar;semantic_vadog detseagernesser den anden løftestang- Koncise systeminstruktioner reducerer modellens behandlingstid
- Parallel udførelse af funktionskald og caching reducerer applikationslatens
- Et overvågningssystem med TTFA (Time-to-First-Audio) er afgørende for løbende optimering