Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Latens och optimering i realtid

Lektion 17 av 18 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Latens och optimering i realtid
  2. Latensens anatomi
  3. Optimering av VAD-detektering
  4. Optimering av systeminstruktioner
  5. Minskning av nätverkslatens
  6. Optimering av funktionsanrop
  7. Latensövervakning
  8. Viktiga punkter

Uppdaterad 2 november 2026 — Ljudmodeller. Flera modeller i denna kurs är avvecklade: tts-1, tts-1-hd och gpt-4o-mini-tts upphö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-realtime och äldre ljudmodeller den 20 januari 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe och /v1/audio/translations den 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:

VAD
Väntan på tystnaden som avslutar turtagningen (`silence_duration_ms`)
Nätverk
Tur-och-retur mellan användaren, din server och API:t
Modell
Kontextbearbetning, sedan första ljudklumpen

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_ms styr direkt väntetiden före svar; semantic_vad och dess eagerness ä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