Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Produkce: Škálování a monitorování

Lekce 18 z 18 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Produkce: Škálování a monitorování
  2. Produkční architektura
  3. Správa souběžných relací
  4. Strukturované logování
  5. Metriky Prometheus
  6. Správa nákladů
  7. Zpracování chyb v produkci
  8. Klíčové poznatky
  9. Ověř si své znalosti

Aktualizováno 2. listopadu 2026 — Zvukové modely. Několik modelů v tomto kurzu je zastaralých: tts-1, tts-1-hd a gpt-4o-mini-tts př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-realtime a starší zvukové modely skončí 20. ledna 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe a /v1/audio/translations skončí 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 SDK openai verze 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ů:

1

Load Balancer (nginx / HAProxy)

Rozděluje příchozí WebSocket připojení mezi workery. Podporuje sticky sessions pro udržení affinity.

2

Workery (FastAPI + uvicorn)

Každý worker obsluhuje díky asyncio více současných relací Realtime.

3

Databáze (PostgreSQL)

Ukládá logy konverzací, metriky a konfiguraci agenta.

4

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í
  • SessionManager se 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é
  • CostController omezuje 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.