Latens och optimering i realtid
På denna sida
Uppdaterad 2 november 2026 — Ljudmodeller. Flera modeller i denna kurs är avvecklade:
tts-1,tts-1-hdochgpt-4o-mini-ttsupphör den 6 januari 2027 (efträdare:gpt-realtime-2.1-mini, vilket OpenAI:s TTS-guide anger inte stöds av/v1/audio/speech: migrering av röstsyntes flyttas till Realtime API);gpt-realtime,gpt-4o-realtimeoch äldre ljudmodeller den 20 januari 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeoch/v1/audio/translationsden 26 februari 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). För full-duplex-röst har GPT-Live 1 funnits tillgänglig i API:t sedan 10 september 2026.
Korrigerad 3 november 2026. De varaktigheter som tilldelats varje steg (“VAD 300–700 ms”, “nätverk 20–100 ms”, “modell 200–800 ms”) och perceptionströsklar (“bortom 500 ms”) saknade källor: OpenAI publicerar inte sådana siffror, och lektionen lär dig nu hur du mäter dem. Instruktionen att placera din server “i samma region som OpenAI:s servrar (US East)” togs bort på grund av bristande källhänvisning. Dokumenterade tillägg:
semantic_vad, WARP för att påskynda etablering av WebRTC-sessioner. Källor: Voice activity detection · WebRTC with WARP · Cost optimization.
Latens och optimering i realtid
Latens är fiende nummer ett för en röstagent: tystnaden som följer efter slutet på en fråga märks omedelbart i telefonen eller i en applikation. Denna lektion går igenom källorna till latens, hur du mäter dem och tekniker för att reducera dem.
Latensens anatomi
Den totala latensen för en röstagent är summan av flera komponenter:
Beroende på din arkitektur lägger du till de verktyg agenten anropar och tiden för sessionsstart. Ingen av dessa varaktigheter är fastställd: de beror på dina inställningar, samtalets längd och nätverksvägen. Det enda sättet att veta var tiden går åt är att ta tid på varje steg, precis som monitorn nedan gör.
Optimering av VAD-detektering
Med server_vad kan svaret inte starta förrän tystnaden definierad av silence_duration_ms har upphört: detta är alltså en direkt inställning för den upplevda latensen, som måste balanseras mot risken att avbryta användaren. Värdena nedan är utgångspunkter att testa, inte rekommendationer från OpenAI:
# Aggressiv konfiguration (snabbt svar, risk att klippa av användaren)
fast_vad = {
"type": "server_vad",
"threshold": 0.6, # Högre tröskel = färre falska positiva
"prefix_padding_ms": 200,
"silence_duration_ms": 400 # Snabb reaktion
}
# Tålmodig konfiguration (färre avbrott, mer latens)
patient_vad = {
"type": "server_vad",
"threshold": 0.4,
"prefix_padding_ms": 400,
"silence_duration_ms": 800
}
# Alternativ: semantisk VAD, som bedömer meningslut baserat på ord;
# eagerness "high" svarar så snart som möjligt, "low" låter användaren avsluta
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}
# Adaptiv konfiguration baserad på kontext
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 av systeminstruktioner
Koncisa instruktioner minskar kontexten som ska bearbetas. Kom också ihåg att Realtime API automatiskt tillämpar prompt-cachning: stabila instruktioner och verktyg, placerade högst upp och aldrig modifierade under en session, återanvänds från tur till tur.
# Utförliga instruktioner (fler token att bearbeta)
bad_instructions = """
Du är en intelligent och kompetent röstassistent som arbetar
för Corsen AI, ett franskt företag specialiserat på
artificiell intelligens. Du måste svara på användarens frågor
professionellt, koncist och på franska.
Du har tillgång till olika verktyg för att konsultera bokningar,
kontrollera tillgänglighet och göra reservationer.
Tveka inte att be om förtydligande om begäran är oklar.
"""
# Optimerade instruktioner (samma effekt, färre token)
good_instructions = """
Röstassistent för Corsen AI. Franska, koncist, professionellt.
Använd verktyg för bokningar och reservationer.
Be om förtydligande vid behov.
"""
Minskning av nätverkslatens
Mätning av tur-och-retur
Placera din WebSocket-relä så nära dina användare som möjligt och mät vägen istället för att gissa. En enkel händelse, som att rensa inmatningsbufferten, räcker för att ta tid på en tur-och-retur:
import time
async def measure_roundtrip(ws):
"""Mäter nätverkslatens till 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 # ignorera andra händelser som anländer emellan
roundtrip_ms = (time.monotonic() - start) * 1000
print(f"Nätverkslatens: {roundtrip_ms:.0f} ms")
return roundtrip_ms
Keepalive och återanslutning
import asyncio
import websockets
async def robust_connection(api_key: str, max_retries: int = 5):
"""Robust anslutning med automatisk återanslutning."""
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 var 20:e sekund
ping_timeout=10, # Timeout för ping 10 s
close_timeout=5 # Timeout för stängning 5 s
) as ws:
retry_count = 0 # Återställ vid lyckad anslutning
yield ws
except websockets.exceptions.ConnectionClosed:
retry_count += 1
wait = min(2 ** retry_count, 30)
print(f"Återansluter om {wait}s...")
await asyncio.sleep(wait)
En återanslutning öppnar en ny session: det tidigare samtalet finns inte längre kvar, och en session varar ändå högst 60 minuter. Så håll din egen registrering av utbyten (transkriberingar, verktygsresultat) och injicera det väsentliga på nytt med conversation.item.create efter en återanslutning.
Påskyndande av WebRTC-etablering: WARP
På webbläsar- eller native-app-sidan dokumenterar OpenAI WARP (WebRTC Abridged Roundtrip Protocol), vilket reducerar etableringstiden för WebRTC-sessioner genom att kombinera tre transportoptimeringar: DTLS 1.3, SPED och SNAP. Dessa är IETF-utkast, stödda av senaste versionerna av libwebrtc; du kan aktivera de som din klient stöder, en efter en. Guiden WebRTC with WARP detaljerar konfigurationen.
Optimering av funktionsanrop
Funktionsanrop lägger till latens. Optimera deras exekvering:
import asyncio
async def execute_functions_parallel(function_calls: list) -> list:
"""Exekverar funktionsanrop parallellt."""
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 för frekventa funktioner
from functools import lru_cache
@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
"""Cachar resultat av frekventa förfrågningar."""
# Databas- eller API-fråga
return {"data": "..."}
Latensövervakning
Integrera ett mätsystem för att identifiera flaskhalsar:
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)
Viktiga punkter
- Total latens summerar VAD, nätverk, modell och verktyg: mät varje steg, OpenAI publicerar inte typiska varaktigheter
silence_duration_msstyr direkt väntetiden före svar;semantic_vadoch desseagernessär den andra hävstången- Koncisa systeminstruktioner minskar modellens bearbetningstid
- Parallell exekvering av funktionsanrop och cachning minskar applikationslatens
- Ett övervakningssystem med TTFA (Time-to-First-Audio) är avgörande för kontinuerlig optimering