Премини към основното съдържание
Български— Изберете език
Меню

Продукция: Мащабиране и наблюдение

Урок 18 от 18 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. Продукция: Мащабиране и наблюдение
  2. Продукционна архитектура
  3. Управление на едновременни сесии
  4. Структурирано записване в дневник
  5. Метрики на Prometheus
  6. Управление на разходите
  7. Обработка на грешки в продукция
  8. Ключови изводи
  9. Проверете знанията си

Обновено на 2 ноември 2026 г. — Аудио модели. Няколко модела в този курс са депрецирали: tts-1, tts-1-hd и gpt-4o-mini-tts ще спрат да работят на 6 януари 2027 г. (замяна: gpt-realtime-2.1-mini, който според ръководството на OpenAI за TTS не се поддържа от /v1/audio/speech: миграцията на синтез на реч трябва да премине през Realtime API); gpt-realtime, gpt-4o-realtime и наследените аудио модели на 20 януари 2027 г. (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe и /v1/audio/translations на 26 февруари 2027 г. (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). За дуплексна гласова връзка, GPT-Live 1 е наличен в API от 10 септември 2026 г.

Обновено на 3 ноември 2026 г. Управлението на разходите преди се събираше в едно изречение; сега то отразява модела за таксуване, описан от OpenAI (таксуване на отговор, връщане на разговора при всяка стъпка, аудио, броено в токени, автоматично кеширане, транскрипция, таксувана отделно) и съкращаване чрез retention_ratio, чийто формат беше проверен спрямо типовете на SDK openai версия 3.42.1. Източник: Оптимизация на разходите.

Продукция: Мащабиране и наблюдение

Преминаването от прототип на гласов агент към надеждна, мащабируема производствена услуга изисква голямо внимание към инфраструктурата, наблюдението и обработката на грешки. Този последен урок обхваща оперативните основи за внедряване на гласов агент в реални условия.

Продукционна архитектура

В производствена среда гласовият агент работи зад балансировщик на натоварването и пул от работници:

1

Балансировщик на натоварването (nginx / HAProxy)

Разпределя входящите WebSocket връзки между работниците. Поддържа лепкави сесии за запазване на афинитета.

2

Работници (FastAPI + uvicorn)

Всеки работник обработва множество едновременни Realtime сесии благодарение на asyncio.

3

База данни (PostgreSQL)

Съхранява дневници на разговорите, метрики и конфигурация на агента.

4

Наблюдение (Prometheus + Grafana)

Събира метрики в реално време: латентност, брой сесии, грешки, разходи.

Управление на едновременни сесии

Всяка WebSocket връзка поддържа сесия на Realtime API. Броят на едновременните сесии е ограничен от Вашите лимити на честота в OpenAI и капацитета на Вашите работници:

import asyncio
from dataclasses import dataclass

@dataclass
class SessionManager:
    """Управлява едновременни сесии на 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):
        """Създава нова сесия с контрол на конкурентността."""
        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):
        """Правилно затваря сесията."""
        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)

Структурирано записване в дневник

Записвайте всяко взаимодействие за отстраняване на грешки и съответствие:

import logging
import json
from datetime import datetime

class ConversationLogger:
    """Структуриран записващ механизъм за гласови разговори."""

    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):
        """Записва пълния дневник в базата данни."""
        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)
            )

Метрики на Prometheus

Изложете метрики за наблюдение в реално време:

from prometheus_client import Counter, Histogram, Gauge, start_http_server

# Ключови метрики
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
)

# Стартиране на сървъра за метрики
start_http_server(9090)

Управление на разходите

Според ръководството на OpenAI за Оптимизация на разходите, сесия за разговор в Realtime се таксува на отговор, във входни и изходни токени за текст, аудио и изображения. Три механизма движат по-голямата част от сметката:

  • Целият разговор се изпраща обратно към модела с всеки отговор: по-късните стъпки струват повече от по-ранните.
  • Аудиото се брои в токени: 1 токен на 100 ms потребителско аудио, 1 токен на 50 ms аудио на асистента.
  • Кеширането на подсказки се прилага автоматично: докато началото на разговора не се променя, то се таксува с намалената ставка за кеширани токени. Промяната или изтриването на по-стар елемент „разбива“ кеша от този момент нататък.

Входната транскрипция, ако е активирана, се таксува отделно по собствената ставка на модела: gpt-transcribe се таксува по продължителност, прочетена от събитието conversation.item.input_audio_transcription.completed. Консумацията за всеки отговор се появява в response.done, под response.usage (total_tokens, input_tokens, output_tokens, плюс разбивка за текст, аудио, изображение и кеш).

За ограничаване на размера на контекста – и следователно на разходите за по-късни стъпки – сесията приема правило за съкращаване: отвъд лимита най-старите съобщения се изхвърлят. Когато retention_ratio е зададено под 1, сървърът премахва малко повече от необходимото, което разрежда съкращенията и запазва кеша:

await ws.send(json.dumps({
    "type": "session.update",
    "session": {
        "type": "realtime",
        "truncation": {
            "type": "retention_ratio",
            "retention_ratio": 0.8,
            "token_limits": {"post_instructions": 8000},
        },
    },
}))

Компромисът: агент, който запазва по-малко контекст, забравя по-бързо. Допълнете това с лимити на сесиите във Вашия код:

class CostController:
    """Контролира разходите за 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 ""

Обработка на грешки в продукция

async def production_event_loop(ws, logger, cost_ctrl):
    """Стабилен цикъл на събития за продукция."""
    cost_ctrl.start()

    try:
        async for raw in ws:
            event = json.loads(raw)
            t = event["type"]

            # Проверка на лимитите за разходи
            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()

Ключови изводи

  • Продукционната архитектура разделя балансировщика на натоварването, asyncio работниците, базата данни и наблюдението
  • SessionManager със семафор контролира броя на едновременните сесии
  • Структурираното записване в JSON позволява отстраняване на грешки и съответствие (запис на разговори)
  • Метриките на Prometheus (TTFA, продължителност, токени, грешки) са съществени за ежедневните операции
  • CostController ограничава продължителността на сесията и токените, за да предотврати превишаване на бюджета

Проверете знанията си

Пет въпроса, обхващащи цялата гласова верига, от WebSocket до внедряване в продукция.

1. Защо Realtime API използва WebSocket вместо HTTP заявки?

Отговор: Защото постоянната, двупосочна връзка Ви позволява да предавате аудио от микрофона и да получавате отговори непрекъснато, без да плащате разхода за установяване на заявка за всяка размяна. Това е предпоставка за разговор с ниска латентност.

2. Какво трябва да изпратите веднага след `session.created` и защо?

Отговор: session.update, незабавно: тук конфигурирате гласа, инструкциите, инструментите и аудио формата. Докато това съобщение не бъде изпратено, сесията работи със стойности по подразбиране.

3. Защо прокси сървърът е съществен в продукция?

Отговор: Той предотвратява разкриването на API ключа в клиента и Ви позволява да удостоверявате потребителя, да ограничавате консумацията и да записвате обажданията – три неща, невъзможни, ако браузърът говори директно с API.

4. Каква е целта на параметъра `prompt` в API за транскрипция?

Отговор: Да насочи разпознаването към очаквания речник: собствени имена, марки, жаргон в областта. Термините, които изброите там, се транскрибират много по-точно.

5. Кой е основният лост за възприеманата латентност при гласов агент?

Отговор: Поточно предаване от край до край: възпроизвеждане на аудио веднага щом пристигнат първите фрагменти, вместо да се чака пълният отговор, и обработка на прекъсвания, така че потребителят да може да се намеси по всяко време.