Optymalizacja opóźnień i działania w czasie rzeczywistym
Na tej stronie
Zaktualizowano 2 listopada 2026 — Modele audio. Kilka modeli w tym kursie jest przestarzałych:
tts-1,tts-1-hdorazgpt-4o-mini-ttsprzestaną działać 6 stycznia 2027 r. (następca:gpt-realtime-2.1-mini, który zgodnie z przewodnikiem OpenAI TTS nie jest obsługiwany przez/v1/audio/speech: migracja syntezy głosu przechodzi do Realtime API);gpt-realtime,gpt-4o-realtimeoraz starsze modele audio 20 stycznia 2027 r. (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeoraz/v1/audio/translations26 lutego 2027 r. (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). W przypadku głosu pełnodupleksowego GPT-Live 1 jest dostępny w API od 10 września 2026 r.
Skorygowano 3 listopada 2026 r. Czasy przypisane do każdego etapu („VAD 300–700 ms“, „sieć 20–100 ms“, „model 200–800 ms“) oraz progi percepcji („powyżej 500 ms“) nie miały źródeł: OpenAI nie publikuje takich danych, dlatego lekcja uczy teraz, jak je mierzyć. Usunięto zalecenie umieszczania serwera „w tym samym regionie co serwery OpenAI (US East)“ z powodu braku potwierdzenia. Dodano udokumentowane elementy:
semantic_vad, WARP przyspieszający nawiązywanie sesji WebRTC. Źródła: Wykrywanie aktywności głosowej · WebRTC z WARP · Optymalizacja kosztów.
Optymalizacja opóźnień i działania w czasie rzeczywistym
Opóźnienie to główny wróg agenta głosowego: cisza następująca po zakończeniu pytania jest natychmiast zauważalna w rozmowie telefonicznej lub w aplikacji. W tej lekcji szczegółowo omówimy źródła opóźnień, metody ich pomiaru oraz techniki ich redukcji.
Anatomia opóźnienia
Całkowite opóźnienie agenta głosowego to suma kilku składników:
W zależności od Twojej architektury dodaj czasy wywoływania narzędzi przez agenta oraz czas inicjalizacji sesji. Żaden z tych czasów nie jest stały: zależą one od Twoich ustawień, długości rozmowy i ścieżki sieciowej. Jedynym sposobem, aby dowiedzieć się, gdzie ucieka czas, jest mierzenie każdego kroku, tak jak robi to przedstawiony poniżej monitor.
Optymalizacja wykrywania VAD
Przy użyciu server_vad odpowiedź nie może rozpocząć się przed upływem ciszy zdefiniowanej przez silence_duration_ms: jest to więc bezpośrednie ustawienie wpływające na postrzegane opóźnienie, które należy zrównoważyć z ryzykiem przerwania użytkownikowi. Poniższe wartości to punkty wyjścia do testów, a nie rekomendacje OpenAI:
# Konfiguracja agresywna (szybka odpowiedź, ryzyko ucięcia wypowiedzi użytkownika)
fast_vad = {
"type": "server_vad",
"threshold": 0.6, # Wyższy próg = mniej fałszywych wykryć
"prefix_padding_ms": 200,
"silence_duration_ms": 400 # Szybka reakcja
}
# Konfiguracja cierpliwa (mniej przerwań, większe opóźnienie)
patient_vad = {
"type": "server_vad",
"threshold": 0.4,
"prefix_padding_ms": 400,
"silence_duration_ms": 800
}
# Alternatywa: semantic VAD, który ocenia koniec zdania na podstawie słów;
# eagerness "high" odpowiada natychmiast, "low" pozwala użytkownikowi dokończyć
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}
# Konfiguracja adaptacyjna w zależności od kontekstu
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
}
Optymalizacja instrukcji systemowych
Zwięzłe instrukcje redukują kontekst do przetworzenia. Pamiętaj też, że Realtime API automatycznie stosuje buforowanie promptów: stabilne instrukcje i narzędzia, umieszczone na początku i niemodyfikowane podczas sesji, są wykorzystywane z tury na turę.
# Rozgadane instrukcje (więcej tokenów do przetworzenia)
bad_instructions = """
Jesteś inteligentnym i kompetentnym asystentem głosowym pracującym
dla Corsen AI, francuskiej firmy specjalizującej się w
sztucznej inteligencji. Musisz odpowiadać na pytania użytkownika
profesjonalnie, zwięźle i w języku francuskim.
Masz dostęp do różnych narzędzi do sprawdzania spotkań,
dostępności i dokonywania rezerwacji.
Nie wahaj się prosić o wyjaśnienia, jeśli żądanie jest niejasne.
"""
# Zoptymalizowane instrukcje (ten sam efekt, mniej tokenów)
good_instructions = """
Asystent głosowy Corsen AI. Francuski, zwięzły, profesjonalny.
Używaj narzędzi do spotkań i rezerwacji.
W razie potrzeby pytaj o wyjaśnienia.
"""
Redukcja opóźnień sieciowych
Pomiar czasu round-trip
Umieść swoje przekaźniki WebSocket jak najbliżej użytkowników i mierz ścieżkę, zamiast zakładać jej parametry. Proste zdarzenie, takie jak wyczyszczenie bufora wejściowego, wystarczy do zmierzenia czasu round-trip:
import time
async def measure_roundtrip(ws):
"""Mierzy opóźnienie sieciowe do 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 # ignoruj inne zdarzenia przychodzące w międzyczasie
roundtrip_ms = (time.monotonic() - start) * 1000
print(f"Opóźnienie sieciowe: {roundtrip_ms:.0f} ms")
return roundtrip_ms
Keepalive i ponowne łączenie
import asyncio
import websockets
async def robust_connection(api_key: str, max_retries: int = 5):
"""Solidne połączenie z automatycznym ponownym łączeniem."""
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 co 20 s
ping_timeout=10, # Limit czasu pingu 10 s
close_timeout=5 # Limit czasu zamknięcia 5 s
) as ws:
retry_count = 0 # Reset przy udanym połączeniu
yield ws
except websockets.exceptions.ConnectionClosed:
retry_count += 1
wait = min(2 ** retry_count, 30)
print(f"Ponowne łączenie za {wait}s...")
await asyncio.sleep(wait)
Ponowne połączenie otwiera nową sesję: poprzednia rozmowa znika, a sesja i tak trwa maksymalnie 60 minut. Dlatego prowadź własny rejestr wymiany danych (transkrypcje, wyniki narzędzi) i po ponownym połączeniu wstrzyknij niezbędne elementy za pomocą conversation.item.create.
Przyspieszanie konfiguracji WebRTC: WARP
Po stronie przeglądarki lub aplikacji natywnej OpenAI dokumentuje WARP (WebRTC Abridged Roundtrip Protocol), który skraca czas nawiązywania sesji WebRTC dzięki połączeniu trzech optymalizacji transportu: DTLS 1.3, SPED i SNAP. Są to projekty IETF, obsługiwane przez najnowsze wersje libwebrtc; możesz włączyć te, które obsługuje Twój klient, pojedynczo. Przewodnik WebRTC with WARP szczegółowo opisuje konfigurację.
Optymalizacja wywoływania funkcji
Wywołania funkcji dodają opóźnienia. Zoptymalizuj ich wykonywanie:
import asyncio
async def execute_functions_parallel(function_calls: list) -> list:
"""Wykonuje wywołania funkcji równolegle."""
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
# Bufor dla częstych funkcji
from functools import lru_cache
@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
"""Buforuje wyniki częstych żądań."""
# Zapytanie do bazy danych lub API
return {"data": "..."}
Monitorowanie opóźnień
Zintegruj system pomiarowy, aby identyfikować wąskie gardła:
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)
Kluczowe wnioski
- Całkowite opóźnienie to suma VAD, sieci, modelu i narzędzi: mierz każdy krok, OpenAI nie publikuje typowych czasów
silence_duration_msbezpośrednio kontroluje czas oczekiwania przed odpowiedzią;semantic_vadi jegoeagernessto druga dźwignia- Zwięzłe instrukcje systemowe redukują czas przetwarzania przez model
- Równoległe wykonywanie wywołań funkcji i buforowanie redukują opóźnienia aplikacji
- System monitorowania z TTFA (Time-to-First-Audio) jest niezbędny do ciągłej optymalizacji