Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Produkcia: Škálovanie a monitorovanie

Lekcia 18 z 18 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Produkcia: Škálovanie a monitorovanie
  2. Produkčná architektúra
  3. Správa súbežných relácií
  4. Štruktúrované logovanie
  5. Metriky Prometheus
  6. Riadenie nákladov
  7. Spracovanie chýb v produkcii
  8. Kľúčové poznatky
  9. Otestuj si svoje vedomosti

Aktualizované 2. novembra 2026 — Zvukové modely. Niekoľko modelov v tomto kurze je zastaraných: tts-1, tts-1-hd a gpt-4o-mini-tts prestanú 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-realtime a 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-transcribe a /v1/audio/translations 26. 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 SDK openai verzie 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:

1

Load Balancer (nginx / HAProxy)

Rozdeľuje prichádzajúce WebSocket pripojenia medzi workery. Podporuje sticky sessions na udržanie affinity.

2

Workery (FastAPI + uvicorn)

Každý worker vďaka asyncio obsluhuje viacero simultánnych Realtime relácií.

3

Databáza (PostgreSQL)

Ukladá záznamy konverzácií, metriky a konfiguráciu agenta.

4

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
  • SessionManager so 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
  • CostController obmedzuje 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.