Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Latentie en optimalisatie in real-time

Les 17 van 18 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Latentie en optimalisatie in real-time
  2. Anatomie van latentie
  3. VAD-detectie optimaliseren
  4. Systeeminstructies optimaliseren
  5. Netwerklatentie verminderen
  6. Function calling optimaliseren
  7. Latentiemonitoring
  8. Belangrijkste punten

Bijgewerkt 2 november 2026 — Audiomodellen. Verschillende modellen in deze cursus zijn verouderd: tts-1, tts-1-hd en gpt-4o-mini-tts stoppen 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-realtime en legacy audiomodellen op 20 januari 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe en /v1/audio/translations op 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:

VAD
Wachten op de stilte die de beurt beëindigt (`silence_duration_ms`)
Netwerk
Round trips tussen de gebruiker, uw server en de API
Model
Contextverwerking, daarna eerste audiofragment

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_ms stuurt direct de wachttijd voor respons; semantic_vad en de eagerness ervan 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