Produkcia: Škálovanie a monitorovanie
Na tejto strane
Aktualizované 2. novembra 2026 — Zvukové modely. Niekoľko modelov v tomto kurze je zastaraných:
tts-1,tts-1-hdagpt-4o-mini-ttsprestanú fungovať 6. januára 2027 (náhrada:gpt-realtime-2.1-mini, ktorý podľa sprievodcu OpenAI TTS nie je podporovaný cez/v1/audio/speech: migrácia syntézy reči musí prebehnúť cez Realtime API);gpt-realtime,gpt-4o-realtimea staršie zvukové modely 20. januára 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribea/v1/audio/translations26. februára 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pre full-duplex hlasovú komunikáciu je GPT-Live 1 dostupný v API od 10. septembra 2026.
Aktualizované 3. novembra 2026. Riadenie nákladov sa predtým zmestilo do jednej vety; teraz odráža fakturačný model popísaný spoločnosťou OpenAI (fakturácia za odpoveď, konverzácia vracaná v každom kole, audio počítané v tokenoch, automatické ukladanie do cache, prepis fakturovaný samostatne) a orezávanie cez
retention_ratio, ktorého formát bol overený oproti typom SDKopenaiverzie 3.42.1. Zdroj: Optimalizácia nákladov.
Produkcia: Škálovanie a monitorovanie
Prechod od prototypu hlasového agenta k spoľahlivej, škálovateľnej produkčnej službe si vyžaduje veľkú pozornosť venovanú infraštruktúre, monitorovaniu a spracovaniu chýb. Táto záverečná lekcia pokrýva operačné základy nasadenia hlasového agenta v reálnych podmienkach.
Produkčná architektúra
V produkcii beží hlasový agent za záťažovou balansovačkou (load balancer) a poolom workerov:
Load Balancer (nginx / HAProxy)
Rozdeľuje prichádzajúce WebSocket pripojenia medzi workery. Podporuje sticky sessions na udržanie affinity.
Workery (FastAPI + uvicorn)
Každý worker vďaka asyncio obsluhuje viacero simultánnych Realtime relácií.
Databáza (PostgreSQL)
Ukladá záznamy konverzácií, metriky a konfiguráciu agenta.
Monitorovanie (Prometheus + Grafana)
Zbiera metriky v reálnom čase: latencia, počet relácií, chyby, náklady.
Správa súbežných relácií
Každé WebSocket pripojenie udržiava jednu reláciu Realtime API. Počet simultánnych relácií je obmedzený tvojimi limitmi rýchlosti (rate limits) od OpenAI a kapacitou tvojich workerov:
import asyncio
from dataclasses import dataclass
@dataclass
class SessionManager:
"""Spravuje súbežné relácie 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):
"""Vytvorí novú reláciu s kontrolou súbež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ávne uzavrie reláciu."""
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)
Štruktúrované logovanie
Loguj každú interakciu kvôli ladeniu a compliance:
import logging
import json
from datetime import datetime
class ConversationLogger:
"""Štruktúrovaný logger pre hlasové konverzácie."""
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):
"""Uloží kompletný log do databázy."""
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 pre monitorovanie v reálnom čase:
from prometheus_client import Counter, Histogram, Gauge, start_http_server
# Kľúčové metriky
sessions_active = Gauge(
"voice_sessions_active",
"Počet aktívnych hlasových relácií"
)
session_duration = Histogram(
"voice_session_duration_seconds",
"Dĺžka trvania hlasových relácií",
buckets=[30, 60, 120, 300, 600, 1800]
)
response_latency = Histogram(
"voice_response_latency_ms",
"Latencia odpovede (koniec reči → prvé audio)",
buckets=[200, 400, 600, 800, 1000, 1500, 2000, 3000]
)
errors_total = Counter(
"voice_errors_total",
"Celkový počet chýb",
["error_type"]
)
tokens_used = Counter(
"voice_tokens_total",
"Spotrebované tokeny",
["type"] # input_audio, output_audio, input_text, output_text
)
# Spustenie servera metrík
start_http_server(9090)
Riadenie nákladov
Podľa sprievodcu Cost optimization od OpenAI sa relácia konverzácie Realtime fakturuje za odpoveď, vo vstupných a výstupných tokenoch pre text, audio a obrázky. Tri mechanizmy poháňajú väčšinu faktúry:
- Celá konverzácia sa odosiela modelu späť s každou odpoveďou: neskoršie kolá stoja viac ako tie skoršie.
- Audio sa počíta v tokenoch: 1 token za 100 ms používateľovho audia, 1 token za 50 ms audia asistenta.
- Ukladanie promptov do cache (prompt caching) platí automaticky: pokiaľ sa začiatok konverzácie nemení, fakturuje sa zníženou sadzbou za tokeny v cache. Úprava alebo vymazanie staršieho prvku „rozbije“ cache od daného bodu ďalej.
Vstupný prepis, ak je povolený, sa fakturuje samostatne podľa sadzby vlastného modelu: gpt-transcribe sa účtuje podľa dĺžky trvania, čítanej z udalosti conversation.item.input_audio_transcription.completed. Spotreba pre každú odpoveď sa objaví v response.done, pod response.usage (total_tokens, input_tokens, output_tokens, plus rozpis pre text, audio, obrázok a cache).
Na obmedzenie veľkosti kontextu – a tým aj nákladov neskorších kôl – relácia akceptuje pravidlo orezania (truncation): po prekročení limitu sa najstaršie správy zahodia. Ak je retention_ratio nastavené pod 1, server odstráni o niečo viac, než je nutné, čo rozostrie orezávania a zachová 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: agent, ktorý si ponecháva menej kontextu, rýchlejšie zabúda. Doplň to limitmi relácií vo svojom kóde:
class CostController:
"""Kontroluje náklady pre reláciu 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 ""
Spracovanie chýb v produkcii
async def production_event_loop(ws, logger, cost_ctrl):
"""Robustná slučka udalostí pre produkciu."""
cost_ctrl.start()
try:
async for raw in ws:
event = json.loads(raw)
t = event["type"]
# Kontrola limitov nákladov
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()
Kľúčové poznatky
- Produkčná architektúra oddeľuje load balancer, asyncio workery, databázu a monitorovanie
SessionManagerso semaforom kontroluje počet simultánnych relácií- Štruktúrované logovanie v JSON umožňuje ladenie a compliance (nahrávanie konverzácií)
- Metriky Prometheus (TTFA, dĺžka trvania, tokeny, chyby) sú nevyhnutné pre každodenné operácie
CostControllerobmedzuje dĺžku relácie a počet tokenov, aby sa predišlo prekročeniu rozpočtu
Otestuj si svoje vedomosti
Päť otázok pokrývajúcich celý hlasový reťazec, od WebSocketu až po nasadenie do produkcie.
1. Prečo Realtime API používa WebSocket namiesto HTTP požiadaviek?
Odpoveď: Pretože trvalé, obojsmerné pripojenie ti umožňuje streamovať audio z mikrofónu a nepretržite prijímať odpovede bez nutnosti platiť réžiu za nadväzovanie požiadavky pri každej výmene. Toto je predpokladom pre konverzáciu s nízkou latenciou.
2. Čo musíš odoslať okamžite po `session.created` a prečo?
Odpoveď: session.update, okamžite: tu konfiguruješ hlas, inštrukcie, nástroje a formát audia. Kým nie je táto správa odoslaná, relácia beží s predvolenými hodnotami.
3. Prečo je proxy server v produkcii nevyhnutný?
Odpoveď: Zabraňuje vystaveniu API kľúča v klientovi a umožňuje ti autentifikovať používateľa, obmedziť spotrebu a logovať volania – tri veci, ktoré sú nemožné, ak prehliadač komunikuje priamo s API.
4. Aký je účel parametra `prompt` v API pre prepis?
Odpoveď: Nasmerovať rozpoznávanie smerom k očakávanej slovnej zásobe: vlastné mená, značky, odborný žargón. Termíny, ktoré tam uvedieš, sa prepisujú oveľa presnejšie.
5. Čo je hlavnou pákou pre vnímanú latenciu u hlasového agenta?
Odpoveď: End-to-end streaming: prehrávanie audia hneď, ako prídu prvé fragmenty, namiesto čakania na celú odpoveď, a spracovanie prerušenia, aby mohol používateľ vstúpiť do reči kedykoľvek.