Latentie en optimalisatie in real-time
Op deze pagina
Bijgewerkt 2 november 2026 — Audiomodellen. Verschillende modellen in deze cursus zijn verouderd:
tts-1,tts-1-hdengpt-4o-mini-ttsstoppen op 6 januari 2027 (opvolger:gpt-realtime-2.1-mini, waarvan de OpenAI TTS-gids aangeeft dat deze niet wordt ondersteund door/v1/audio/speech: migratie van spraaksynthese gaat naar de Realtime API);gpt-realtime,gpt-4o-realtimeen legacy audiomodellen op 20 januari 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeen/v1/audio/translationsop 26 februari 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Voor full-duplex spraak is GPT-Live 1 beschikbaar in de API sinds 10 september 2026.
Gecorrigeerd 3 november 2026. De duur die aan elke stap werd toegewezen (“VAD 300-700 ms”, “netwerk 20-100 ms”, “model 200-800 ms”) en perceptiedrempels (“boven 500 ms”) misten bronnen: OpenAI publiceert dergelijke cijfers niet, en de les leert u nu hoe u ze meet. De instructie om uw server “in dezelfde regio als OpenAI-servers (US East)” te plaatsen, is verwijderd wegens gebrek aan onderbouwing. Gedocumenteerde toevoegingen:
semantic_vad, WARP om WebRTC-sessieopstart te versnellen. Bronnen: Voice activity detection · WebRTC with WARP · Cost optimization.
Latentie en optimalisatie in real-time
Latentie is de grootste vijand van een voice agent: de stilte na het einde van een vraag valt direct op aan de telefoon of in een applicatie. Deze les behandelt de bronnen van latentie, hoe u deze meet, en technieken om ze te verminderen.
Anatomie van latentie
De totale latentie van een voice agent is de som van verschillende componenten:
Afhankelijk van uw architectuur komen daar de tools bij die de agent aanroept en de tijd voor sessieopstart. Geen van deze duurwaarden is vast: ze hangen af van uw instellingen, gesprekslengte en netwerkroute. De enige manier om te weten waar de tijd naartoe gaat, is elke stap timen, zoals de onderstaande monitor doet.
VAD-detectie optimaliseren
Bij server_vad kan de respons niet beginnen voordat de stilte gedefinieerd door silence_duration_ms voorbij is: dit is dus een directe instelling voor de waargenomen latentie, die u moet afwegen tegen het risico dat u de gebruiker onderbreekt. De onderstaande waarden zijn startpunten om te testen, geen OpenAI-aanbevelingen:
# Aggressieve configuratie (snelle respons, risico op afkappen gebruiker)
fast_vad = {
"type": "server_vad",
"threshold": 0.6, # Hogere drempel = minder false positives
"prefix_padding_ms": 200,
"silence_duration_ms": 400 # Snelle reactie
}
# Geduldige configuratie (minder onderbrekingen, meer latentie)
patient_vad = {
"type": "server_vad",
"threshold": 0.4,
"prefix_padding_ms": 400,
"silence_duration_ms": 800
}
# Alternatief: semantische VAD, die zindeinde beoordeelt op basis van woorden;
# eagerness "high" reageert zo snel mogelijk, "low" laat de gebruiker uitpraten
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}
# Adaptieve configuratie op basis van context
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
}
Systeeminstructies optimaliseren
Beknopte instructies verkleinen de te verwerken context. Bedenk ook dat de Realtime API prompt-caching automatisch toepast: stabiele instructies en tools, bovenaan geplaatst en tijdens een sessie nooit gewijzigd, worden van beurt tot beurt hergebruikt.
# Uitgebreide instructies (meer tokens om te verwerken)
bad_instructions = """
You are an intelligent and competent voice assistant working
for Corsen AI, a French company specializing in
artificial intelligence. You must answer user questions
professionally, concisely, and in French.
You have access to various tools to consult appointments,
check availability, and make reservations.
Do not hesitate to ask for clarification if the request is unclear.
"""
# Geoptimaliseerde instructies (zelfde effect, minder tokens)
good_instructions = """
Corsen AI voice assistant. French, concise, professional.
Use tools for appointments and reservations.
Ask for clarification if needed.
"""
Netwerklatentie verminderen
Round trip meten
Plaats uw WebSocket-relay zo dicht mogelijk bij uw gebruikers en meet het pad in plaats van ervan uit te gaan. Een simpele gebeurtenis, zoals het leegmaken van de inputbuffer, volstaat om een round trip te timen:
import time
async def measure_roundtrip(ws):
"""Meet netwerklatentie naar de 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 # negeer andere events die tussendoor binnenkomen
roundtrip_ms = (time.monotonic() - start) * 1000
print(f"Network latency: {roundtrip_ms:.0f} ms")
return roundtrip_ms
Keepalive en herverbinding
import asyncio
import websockets
async def robust_connection(api_key: str, max_retries: int = 5):
"""Robuuste verbinding met automatische herverbinding."""
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 elke 20s
ping_timeout=10, # Ping-time-out 10s
close_timeout=5 # Sluit-time-out 5s
) as ws:
retry_count = 0 # Reset bij succesvolle verbinding
yield ws
except websockets.exceptions.ConnectionClosed:
retry_count += 1
wait = min(2 ** retry_count, 30)
print(f"Reconnecting in {wait}s...")
await asyncio.sleep(wait)
Een herverbinding opent een nieuwe sessie: het vorige gesprek is er niet meer, en een sessie duurt sowieso maximaal 60 minuten. Houd daarom zelf een register bij van uitwisselingen (transcripties, tool-resultaten) en injecteer het essentiële opnieuw met conversation.item.create na een herverbinding.
WebRTC-opstart versnellen: WARP
Aan de kant van de browser of native app documenteert OpenAI WARP (WebRTC Abridged Roundtrip Protocol), dat de tijd voor WebRTC-sessieopstart vermindert door drie transportoptimalisaties te combineren: DTLS 1.3, SPED en SNAP. Dit zijn IETF-drafts, ondersteund door recente versies van libwebrtc; u kunt die inschakelen die uw client ondersteunt, één voor één. De gids WebRTC with WARP beschrijft de configuratie in detail.
Function calling optimaliseren
Functieaanroepen voegen latentie toe. Optimaliseer hun uitvoering:
import asyncio
async def execute_functions_parallel(function_calls: list) -> list:
"""Voert functieaanroepen parallel uit."""
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 voor frequente functies
from functools import lru_cache
@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
"""Cachet resultaten van frequente verzoeken."""
# Database- of API-query
return {"data": "..."}
Latentiemonitoring
Integreer een meetsysteem om knelpunten te identificeren:
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)
Belangrijkste punten
- Totale latentie telt VAD, netwerk, model en tools op: meet elke stap, OpenAI publiceert geen typische duurwaarden
silence_duration_msstuurt direct de wachttijd voor respons;semantic_vaden deeagernesservan zijn de andere hefboom- Beknopte systeeminstructies verminderen de verwerkingstijd van het model
- Parallelle uitvoering van functieaanroepen en caching verminderen applicatie-latentie
- Een monitorsysteem met TTFA (Time-to-First-Audio) is essentieel voor continue optimalisatie