Produkcja: Skalowanie i monitorowanie
Na tej stronie
Zaktualizowano 2 listopada 2026 — Modele audio. Kilka modeli w tym kursie zostało wycofanych:
tts-1,tts-1-hdorazgpt-4o-mini-ttsprzestaną działać 6 stycznia 2027 (zamiennik:gpt-realtime-2.1-mini, który zgodnie z przewodnikiem OpenAI TTS nie jest obsługiwany przez/v1/audio/speech: migracja syntezy mowy musi odbywać się przez Realtime API);gpt-realtime,gpt-4o-realtimeoraz starsze modele audio 20 stycznia 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeoraz/v1/audio/translations26 lutego 2027 (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.
Zaktualizowano 3 listopada 2026. Zarządzanie kosztami, które wcześniej mieściło się w jednym zdaniu, teraz odzwierciedla model rozliczeń opisany przez OpenAI (płatność za odpowiedź, konwersacja zwracana przy każdej turze, audio liczone w tokenach, automatyczne buforowanie, transkrypcja rozliczana osobno) oraz skracanie kontekstu za pomocą
retention_ratio, którego format zweryfikowano względem typów SDKopenaiw wersji 3.42.1. Źródło: Optymalizacja kosztów.
Produkcja: Skalowanie i monitorowanie
Przejście od prototypu agenta głosowego do niezawodnej, skalowalnej usługi produkcyjnej wymaga ścisłej uwagi na infrastrukturę, monitorowanie i obsługę błędów. Ta ostatnia lekcja omawia kluczowe aspekty operacyjne wdrażania agenta głosowego w warunkach rzeczywistych.
Architektura produkcyjna
W środowisku produkcyjnym agent głosowy działa za balanserem obciążenia i pulą workerów:
Balanser obciążenia (nginx / HAProxy)
Rozdziela przychodzące połączenia WebSocket między workery. Obsługuje sesje lepkie (sticky sessions) w celu utrzymania afiniczności.
Workery (FastAPI + uvicorn)
Każdy worker obsługuje wiele jednoczesnych sesji Realtime dzięki asyncio.
Baza danych (PostgreSQL)
Przechowuje dzienniki konwersacji, metryki i konfigurację agenta.
Monitorowanie (Prometheus + Grafana)
Zbiera metryki w czasie rzeczywistym: opóźnienia, liczbę sesji, błędy, koszty.
Zarządzanie sesjami współbieżnymi
Każde połączenie WebSocket utrzymuje sesję Realtime API. Liczba jednoczesnych sesji jest ograniczona limitami przepustowości OpenAI oraz wydajnością twoich workerów:
import asyncio
from dataclasses import dataclass
@dataclass
class SessionManager:
"""Zarządza współbieżnymi sesjami Realtime API."""
max_sessions: int = 50
active_sessions: dict = None
semaphore: asyncio.Semaphore = None
def __post_init__(self):
self.active_sessions = {}
self.semaphore = asyncio.Semaphore(self.max_sessions)
async def create_session(self, session_id: str, config: dict):
"""Tworzy nową sesję z kontrolą współbieżności."""
async with self.semaphore:
if session_id in self.active_sessions:
raise ValueError(f"Session {session_id} already active")
self.active_sessions[session_id] = {
"created_at": asyncio.get_event_loop().time(),
"config": config,
"status": "active"
}
return session_id
async def close_session(self, session_id: str):
"""Prawidłowo zamyka sesję."""
if session_id in self.active_sessions:
del self.active_sessions[session_id]
@property
def active_count(self) -> int:
return len(self.active_sessions)
@property
def available_slots(self) -> int:
return self.max_sessions - self.active_count
session_manager = SessionManager(max_sessions=50)
Ustrukturyzowane logowanie
Loguj każdą interakcję w celach debugowania i zgodności z przepisami:
import logging
import json
from datetime import datetime
class ConversationLogger:
"""Ustrukturyzowany logger dla rozmów głosowych."""
def __init__(self, session_id: str):
self.session_id = session_id
self.logger = logging.getLogger(f"voice.{session_id}")
self.events = []
def log_event(self, event_type: str, data: dict = None):
entry = {
"timestamp": datetime.utcnow().isoformat(),
"session_id": self.session_id,
"event_type": event_type,
"data": data or {}
}
self.events.append(entry)
self.logger.info(json.dumps(entry))
def log_transcription(self, role: str, text: str):
self.log_event("transcription", {
"role": role,
"text": text
})
def log_function_call(self, name: str, args: dict, result: dict, duration_ms: float):
self.log_event("function_call", {
"name": name,
"arguments": args,
"result": result,
"duration_ms": round(duration_ms)
})
def log_error(self, error_type: str, message: str):
self.log_event("error", {
"type": error_type,
"message": message
})
async def save_to_db(self, db_pool):
"""Trwale zapisuje pełny dziennik w bazie danych."""
async with db_pool.acquire() as conn:
await conn.execute(
"INSERT INTO conversation_logs (session_id, events, created_at) "
"VALUES ($1, $2, NOW())",
self.session_id, json.dumps(self.events)
)
Metryki Prometheus
Udostępnij metryki do monitorowania w czasie rzeczywistym:
from prometheus_client import Counter, Histogram, Gauge, start_http_server
# Kluczowe metryki
sessions_active = Gauge(
"voice_sessions_active",
"Number of active voice sessions"
)
session_duration = Histogram(
"voice_session_duration_seconds",
"Duration of voice sessions",
buckets=[30, 60, 120, 300, 600, 1800]
)
response_latency = Histogram(
"voice_response_latency_ms",
"Response latency (end of speech → first audio)",
buckets=[200, 400, 600, 800, 1000, 1500, 2000, 3000]
)
errors_total = Counter(
"voice_errors_total",
"Total number of errors",
["error_type"]
)
tokens_used = Counter(
"voice_tokens_total",
"Tokens consumed",
["type"] # input_audio, output_audio, input_text, output_text
)
# Uruchomienie serwera metryk
start_http_server(9090)
Zarządzanie kosztami
Zgodnie z przewodnikiem Cost optimization od OpenAI, sesja konwersacji Realtime jest rozliczana za każdą odpowiedź, w tokenach wejściowych i wyjściowych dla tekstu, audio i obrazów. Trzy mechanizmy generują większość kosztów:
- Cała konwersacja jest odsyłana do modelu z każdą odpowiedzią: późniejsze tury kosztują więcej niż wcześniejsze.
- Audio jest liczone w tokenach: 1 token na 100 ms audio użytkownika, 1 token na 50 ms audio asystenta.
- Buforowanie promptów działa automatycznie: dopóki początek konwersacji się nie zmienia, jest rozliczany według obniżonej stawki za tokeny buforowane. Modyfikacja lub usunięcie starszego elementu „łamie“ bufor od tego momentu.
Transkrypcja wejściowa, jeśli jest włączona, jest rozliczana osobno według stawki własnego modelu: gpt-transcribe jest płatny za czas trwania, odczytywany z eventu conversation.item.input_audio_transcription.completed. Zużycie dla każdej odpowiedzi pojawia się w response.done, pod response.usage (total_tokens, input_tokens, output_tokens, plus szczegółowy podział na tekst, audio, obraz i cache).
Aby ograniczyć rozmiar kontekstu – a tym samym koszt późniejszych tur – sesja akceptuje regułę skracania: po przekroczeniu limitu najstarsze wiadomości są usuwane. Gdy retention_ratio jest ustawione poniżej 1, serwer usuwa nieco więcej niż konieczne, co rozrzedza momenty skracania i zachowuje cache:
await ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"truncation": {
"type": "retention_ratio",
"retention_ratio": 0.8,
"token_limits": {"post_instructions": 8000},
},
},
}))
Kompromis jest taki: agent, który przechowuje mniej kontekstu, szybciej zapomina. Uzupełnij to limitami sesji w swoim kodzie:
class CostController:
"""Kontroluje koszty sesji Realtime."""
def __init__(self, max_duration_s: int = 600, max_tokens: int = 50000):
self.max_duration_s = max_duration_s
self.max_tokens = max_tokens
self.total_tokens = 0
self.start_time = None
def start(self):
self.start_time = asyncio.get_event_loop().time()
def update_tokens(self, usage: dict):
self.total_tokens += usage.get("total_tokens", 0)
@property
def elapsed_seconds(self) -> float:
if not self.start_time:
return 0
return asyncio.get_event_loop().time() - self.start_time
@property
def should_terminate(self) -> bool:
if self.elapsed_seconds > self.max_duration_s:
return True
if self.total_tokens > self.max_tokens:
return True
return False
@property
def warning_message(self) -> str:
remaining = self.max_duration_s - self.elapsed_seconds
if remaining < 60:
return f"This session will end in {int(remaining)} seconds."
return ""
Obsługa błędów w produkcji
async def production_event_loop(ws, logger, cost_ctrl):
"""Solidna pętla zdarzeń dla środowiska produkcyjnego."""
cost_ctrl.start()
try:
async for raw in ws:
event = json.loads(raw)
t = event["type"]
# Sprawdzenie limitów kosztów
if cost_ctrl.should_terminate:
logger.log_event("session_limit_reached")
await ws.send(json.dumps({
"type": "conversation.item.create",
"item": {
"type": "message",
"role": "user",
"content": [{"type": "input_text",
"text": "The session is approaching its duration limit."}]
}
}))
break
if t == "response.done":
usage = event["response"].get("usage", {})
cost_ctrl.update_tokens(usage)
tokens_used.labels(type="total").inc(usage.get("total_tokens", 0))
elif t == "error":
error = event["error"]
logger.log_error(error["type"], error["message"])
errors_total.labels(error_type=error["type"]).inc()
if error["type"] == "rate_limit_error":
await asyncio.sleep(1)
except websockets.exceptions.ConnectionClosed as e:
logger.log_error("connection_closed", str(e))
except Exception as e:
logger.log_error("unexpected", str(e))
finally:
session_duration.observe(cost_ctrl.elapsed_seconds)
sessions_active.dec()
Kluczowe wnioski
- Architektura produkcyjna rozdziela balanser obciążenia, workery asyncio, bazę danych i system monitorowania
SessionManagerz semaforem kontroluje liczbę jednoczesnych sesji- Ustrukturyzowane logowanie JSON umożliwia debugowanie i zgodność z przepisami (nagrywanie rozmów)
- Metryki Prometheus (TTFA, czas trwania, tokeny, błędy) są niezbędne do codziennych operacji
CostControllerogranicza czas trwania sesji i liczbę tokenów, aby zapobiec przekroczeniu budżetu
Sprawdź swoją wiedzę
Pięć pytań obejmujących cały łańcuch głosowy, od WebSocketu po wdrożenie produkcyjne.
1. Dlaczego Realtime API używa WebSocketu zamiast żądań HTTP?
Odpowiedź: Ponieważ trwałe, dwukierunkowe połączenie pozwala strumieniować audio z mikrofonu i ciągle otrzymywać odpowiedzi, bez ponoszenia narzutu związanego z ustanawianiem żądania dla każdej wymiany. Jest to warunek wstępny rozmowy o niskim opóźnieniu.
2. Co musisz wysłać natychmiast po `session.created` i dlaczego?
Odpowiedź: session.update, natychmiast: to tutaj konfigurujesz głos, instrukcje, narzędzia i format audio. Dopóki ta wiadomość nie zostanie wysłana, sesja działa z wartościami domyślnymi.
3. Dlaczego serwer proxy jest niezbędny w produkcji?
Odpowiedź: Zapobiega ujawnieniu klucza API w kliencie i pozwala uwierzytelnić użytkownika, ograniczyć zużycie oraz logować wywołania – trzy rzeczy niemożliwe, gdy przeglądarka komunikuje się bezpośrednio z API.
4. Jaki jest cel parametru `prompt` w API transkrypcji?
Odpowiedź: Ukierunkowanie rozpoznawania na oczekiwane słownictwo: nazwy własne, marki, żargon branżowy. Terminy tam wymienione są transkrybowane znacznie dokładniej.
5. Jaki jest główny dźwignia wpływająca na postrzegane opóźnienie w agencie głosowym?
Odpowiedź: Strumieniowanie end-to-end: odtwarzanie audio natychmiast po nadejściu pierwszych fragmentów zamiast czekania na pełną odpowiedź oraz obsługa przerwań, aby użytkownik mógł wejść w słowo w dowolnym momencie.