Produkce: Škálování a monitorování
Na této stránce
Aktualizováno 2. listopadu 2026 — Zvukové modely. Několik modelů v tomto kurzu je zastaralých:
tts-1,tts-1-hdagpt-4o-mini-ttspřestanou fungovat 6. ledna 2027 (náhrada:gpt-realtime-2.1-mini, který podle průvodce OpenAI TTS není podporován endpointem/v1/audio/speech: migrace syntézy řeči musí proběhnout přes Realtime API);gpt-realtime,gpt-4o-realtimea starší zvukové modely skončí 20. ledna 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribea/v1/audio/translationsskončí 26. února 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pro plně duplexní hlas je GPT-Live 1 dostupné v API od 10. září 2026.
Aktualizováno 3. listopadu 2026. Správa nákladů se dříve vešla do jedné věty; nyní odráží fakturační model popsaný společností OpenAI (fakturace za odpověď, konverzace vracená v každém kole, audio počítané v tocích, automatické ukládání do mezipaměti, přepis fakturován samostatně) a zkracování pomocí
retention_ratio, jehož formát byl ověřen proti typům SDKopenaiverze 3.42.1. Zdroj: Optimalizace nákladů.
Produkce: Škálování a monitorování
Přechod od prototypu hlasového agenta ke spolehlivé, škálovatelné produkční službě vyžaduje pečlivou pozornost infrastruktuře, monitorování a zpracování chyb. Tato závěrečná lekce pokrývá provozní základy nasazení hlasového agenta v reálných podmínkách.
Produkční architektura
V produkci běží hlasový agent za zátěžovým vyvažovačem a poolem workerů:
Load Balancer (nginx / HAProxy)
Rozděluje příchozí WebSocket připojení mezi workery. Podporuje sticky sessions pro udržení affinity.
Workery (FastAPI + uvicorn)
Každý worker obsluhuje díky asyncio více současných relací Realtime.
Databáze (PostgreSQL)
Ukládá logy konverzací, metriky a konfiguraci agenta.
Monitorování (Prometheus + Grafana)
Shromažďuje metriky v reálném čase: latenci, počet relací, chyby, náklady.
Správa souběžných relací
Každé WebSocket připojení udržuje relaci Realtime API. Počet současných relací je omezen tvými limity rychlosti (rate limits) u OpenAI a kapacitou tvých workerů:
import asyncio
from dataclasses import dataclass
@dataclass
class SessionManager:
"""Spravuje souběžné relace 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):
"""Vytvoří novou relaci s řízením souběžnosti."""
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):
"""Správně ukončí relaci."""
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)
Strukturované logování
Loguj každou interakci pro účely ladění a souladu s předpisy:
import logging
import json
from datetime import datetime
class ConversationLogger:
"""Strukturovaný logger pro hlasové konverzace."""
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):
"""Trvale uloží kompletní log do databáze."""
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)
)
Metriky Prometheus
Vystav metriky pro monitorování v reálném čase:
from prometheus_client import Counter, Histogram, Gauge, start_http_server
# Klíčové metriky
sessions_active = Gauge(
"voice_sessions_active",
"Počet aktivních hlasových relací"
)
session_duration = Histogram(
"voice_session_duration_seconds",
"Délka trvání hlasových relací",
buckets=[30, 60, 120, 300, 600, 1800]
)
response_latency = Histogram(
"voice_response_latency_ms",
"Latence odpovědi (konec řeči → první audio)",
buckets=[200, 400, 600, 800, 1000, 1500, 2000, 3000]
)
errors_total = Counter(
"voice_errors_total",
"Celkový počet chyb",
["error_type"]
)
tokens_used = Counter(
"voice_tokens_total",
"Spotřebované toky",
["type"] # input_audio, output_audio, input_text, output_text
)
# Spuštění serveru metrik
start_http_server(9090)
Správa nákladů
Podle průvodce Cost optimization od OpenAI je relace konverzace Realtime fakturována za odpověď, v vstupních a výstupních tocích pro text, audio a obrázky. Tři mechanismy tvoří většinu faktury:
- Celá konverzace je posílána modelu zpět s každou odpovědí: pozdější kola stojí více než ta dřívější.
- Audio se počítá v tocích: 1 tok na 100 ms uživatelského audia, 1 tok na 50 ms audia asistenta.
- Ukládání promptů do mezipaměti funguje automaticky: dokud se začátek konverzace nemění, je fakturován za sníženou sazbu pro toky v mezipaměti. Úprava nebo smazání staršího prvku „rozbije“ mezipaměť od daného bodu dál.
Vstupní přepis, pokud je povolen, je fakturován samostatně podle sazby vlastního modelu: gpt-transcribe je účtován podle délky, čteno z události conversation.item.input_audio_transcription.completed. Spotřeba pro každou odpověď se objeví v response.done, pod response.usage (total_tokens, input_tokens, output_tokens, plus rozpis pro text, audio, obrázek a mezipaměť).
Pro omezení velikosti kontextu – a tím i nákladů pozdějších kol – relace přijímá pravidlo zkracování: po překročení limitu jsou nejstarší zprávy zahazovány. Pokud je retention_ratio nastaveno pod 1, server odstraní o něco více, než je nutné, což rozestupuje zkracování a zachovává mezipaměť:
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 zní: agent, který si pamatuje méně kontextu, rychleji zapomíná. Doplň to o limity relací ve svém kódu:
class CostController:
"""Řídí náklady pro relaci 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 ""
Zpracování chyb v produkci
async def production_event_loop(ws, logger, cost_ctrl):
"""Robustní smyčka událostí pro produkci."""
cost_ctrl.start()
try:
async for raw in ws:
event = json.loads(raw)
t = event["type"]
# Kontrola limitů nákladů
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()
Klíčové poznatky
- Produkční architektura odděluje zátěžový vyvažovač, workery asyncio, databázi a monitorování
SessionManagerse semaforem řídí počet současných relací- Strukturované logování JSON umožňuje ladění a soulad s předpisy (záznam konverzací)
- Metriky Prometheus (TTFA, délka trvání, toky, chyby) jsou pro každodenní provoz nezbytné
CostControlleromezuje délku relace a počet toků, aby zabránil překročení rozpočtu
Ověř si své znalosti
Pět otázek pokrývajících celý řetězec hlasové komunikace, od WebSocketu až po nasazení do produkce.
1. Proč Realtime API používá WebSocket místo HTTP požadavků?
Odpověď: Protože perzistentní, obousměrné připojení umožňuje streamovat audio z mikrofonu a nepřetržitě přijímat odpovědi, aniž by bylo nutné platit režii za navazování požadavku pro každou výměnu. To je předpokladem pro konverzaci s nízkou latencí.
2. Co musíš odeslat okamžitě po `session.created` a proč?
Odpověď: session.update, okamžitě: zde konfiguruješ hlas, instrukce, nástroje a formát audia. Dokud není tato zpráva odeslána, relace běží s výchozími hodnotami.
3. Proč je v produkci nezbytný proxy server?
Odpověď: Zabraňuje vystavení API klíče na straně klienta a umožňuje ti autentizovat uživatele, omezit spotřebu a logovat volání – tři věci, které jsou nemožné, pokud prohlížeč komunikuje přímo s API.
4. Jaký je účel parametru `prompt` v API pro přepis?
Odpověď: Nasměrovat rozpoznávání směrem k očekávané slovní zásobě: vlastní jména, značky, oborový žargon. Termíny, které zde uvedeš, jsou přepisovány mnohem přesněji.
5. Co je hlavním pákou pro vnímanou latenci u hlasového agenta?
Odpověď: Streamování end-to-end: přehrávání audia, jakmile dorazí první fragmenty, místo čekání na úplnou odpověď, a zpracování přerušení, aby uživatel mohl kdykoli vstoupit do řeči.