Éles környezet: méretezés és monitorozás
Ezen az oldalon
Frissítve: 2026. november 2. – Hangmodellek. A tanfolyam több modellje elavult: a
tts-1,tts-1-hdés agpt-4o-mini-tts2027. január 6-án megszűnik működni (helyettesítőjük:gpt-realtime-2.1-mini, amelyet az OpenAI TTS útmutatója szerint nem támogat a/v1/audio/speech: a beszédszintézis migrációjának a Realtime API-n keresztül kell történnie); agpt-realtime,gpt-4o-realtimeés a régi hangmodellek 2027. január 20-án válnak elavulttá (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5); awhisper-1,gpt-4o-transcribeés a/v1/audio/translationspedig 2027. február 26-án (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). A teljes duplex hangkommunikációhoz a GPT-Live 1 már 2026. szeptember 10. óta elérhető az API-ban.
Frissítve: 2026. november 3. A költséggazdálkodás korábban egyetlen mondatba fért; most már tükrözi az OpenAI által leírt számlázási modellt (válaszonkénti számlázás, minden körben visszaküldött beszélgetés, tokenekben számolt hang, automatikus gyorsítótárazás, külön számlázott átírás), valamint a
retention_ratiosegítségével végzett csonkítást, amelynek formátumát azopenaiSDK 3.42.1-es verziójának típusai alapján ellenőriztük. Forrás: Költségoptimalizálás.
Éles környezet: méretezés és monitorozás
Egy hangalapú ügynök prototípusából megbízható, méretezhető éles szolgáltatást létrehozni szoros figyelmet igényel az infrastruktúra, a monitorozás és a hibakezelés terén. Ez az utolsó lecke lefedi a hangügynök valós körülmények közötti telepítésének működési alapjait.
Éles architektúra
Éles környezetben a hangügynök egy terheléselosztó és egy munkafolyamat-pool (worker pool) mögött fut:
Terheléselosztó (nginx / HAProxy)
Szétosztja a bejövő WebSocket kapcsolatokat a munkafolyamatok között. Támogatja a ragadós munkameneteket (sticky sessions) az affinitás fenntartásához.
Munkafolyamatok (FastAPI + uvicorn)
Minden munkafolyamat az asyncio-nak köszönhetően több egyidejű Realtime munkamenetet is kezel.
Adatbázis (PostgreSQL)
Tárolja a beszélgetési naplókat, a metrikákat és az ügynök konfigurációját.
Monitorozás (Prometheus + Grafana)
Valós idejű metrikákat gyűjt: késleltetés, munkamenetek száma, hibák, költségek.
Egyidejű munkamenetek kezelése
Minden WebSocket kapcsolat egy Realtime API munkamenetet tart fenn. Az egyidejű munkamenetek számát az OpenAI sebességkorlátai és a munkafolyamataid kapacitása korlátozza:
import asyncio
from dataclasses import dataclass
@dataclass
class SessionManager:
"""Egyidejű Realtime API munkameneteket kezel."""
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):
"""Új munkamenetet hoz létre konkurencia-vezérléssel."""
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):
"""Szakszerűen lezár egy munkamenetet."""
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)
Strukturált naplózás
Minden interakciót naplózz hibakeresés és megfelelés céljából:
import logging
import json
from datetime import datetime
class ConversationLogger:
"""Strukturált naplózó hangbeszélgetésekhez."""
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):
"""Tartósítja a teljes naplót az adatbázisban."""
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 metrikák
Tedd elérhetővé a metrikákat valós idejű monitorozáshoz:
from prometheus_client import Counter, Histogram, Gauge, start_http_server
# Kulcsfontosságú metrikák
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
)
# A metrika szerver elindítása
start_http_server(9090)
Költséggazdálkodás
Az OpenAI Költségoptimalizálás útmutatója szerint egy Realtime beszélgetési munkamenet válaszonként kerül számlázásra, bemeneti és kimeneti tokenek alapján szöveg, hang és kép esetén. Három mechanizmus határozza meg a számla nagy részét:
- A teljes beszélgetés visszaküldésre kerül a modellnek minden válasznál: a későbbi körök többe kerülnek, mint a korábbiak.
- A hangot tokenekben számolják: 1 token minden 100 ms felhasználói hangért, 1 token minden 50 ms asszisztens hangért.
- A prompt gyorsítótárazás automatikusan alkalmazásra kerül: amíg a beszélgetés eleje nem változik, addig csökkentett gyorsítótárazott token áron számlázzák. Egy régebbi elem módosítása vagy törlése ettől a ponttól kezdve „megszakítja“ a gyorsítótárat.
A bemeneti átírás, ha engedélyezve van, külön számlázásra kerül a saját modelljének díjszabása szerint: a gpt-transcribe költsége időtartam alapú, amelyet a conversation.item.input_audio_transcription.completed eseményből olvashatsz ki. Az egyes válaszok fogyasztása a response.done alatt jelenik meg, a response.usage mezőben (total_tokens, input_tokens, output_tokens, plusz a szöveg, hang, kép és gyorsítótár lebontása).
A kontextus méretének – és ezáltal a későbbi körök költségének – korlátozására a munkamenet elfogad egy csonkítási szabályt: a limit felett a legrégebbi üzenetek eldobásra kerülnek. Ha a retention_ratio értékét 1 alá állítod, a szerver a szükségesnél kicsit többet távolít el, ami ritkítja a csonkításokat és megőrzi a gyorsítótárat:
await ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"truncation": {
"type": "retention_ratio",
"retention_ratio": 0.8,
"token_limits": {"post_instructions": 8000},
},
},
}))
A kompromisszum: egy ügynök, amely kevesebb kontextust őriz meg, gyorsabban felejt. Ezt egészítsd ki munkamenet-korlátokkal a kódodban:
class CostController:
"""Költségeket vezérel egy Realtime munkamenetben."""
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 ""
Éles hibakezelés
async def production_event_loop(ws, logger, cost_ctrl):
"""Robusztus eseményhurok éles környezethez."""
cost_ctrl.start()
try:
async for raw in ws:
event = json.loads(raw)
t = event["type"]
# Költségkorlátok ellenőrzése
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()
Főbb megállapítások
- Az éles architektúra szétválasztja a terheléselosztót, az asyncio munkafolyamatokat, az adatbázist és a monitorozást.
- Egy szemaforral rendelkező
SessionManagervezérli az egyidejű munkamenetek számát. - A JSON strukturált naplózás lehetővé teszi a hibakeresést és a megfelelést (beszélgetésrögzítés).
- A Prometheus metrikák (TTFA, időtartam, tokenek, hibák) elengedhetetlenek a napi működéshez.
- A
CostControllerkorlátozza a munkamenet időtartamát és a tokeneket a költségvetés túllépésének megelőzése érdekében.
Teszteld a tudásod!
Öt kérdés, amely lefedi a teljes hangláncot a WebSockettől az éles telepítésig.
1. Miért használ WebSocketet a Realtime API HTTP kérések helyett?
Válasz: Mert egy tartós, kétirányú kapcsolat lehetővé teszi a mikrofonhang folyamatos streamelését és a válaszok folyamatos fogadását anélkül, hogy minden egyes cseréhez új kérés felépítésének többletköltségét kellene fizetned. Ez az alacsony késleltetésű beszélgetés előfeltétele.
2. Mit kell azonnal elküldeni a `session.created` után, és miért?
Válasz: A session.update üzenetet, azonnal: itt konfigurálod a hangot, az utasításokat, az eszközöket és a hangformátumot. Ezen üzenet elküldéséig a munkamenet alapértelmezett értékekkel fut.
3. Miért elengedhetetlen egy proxy szerver éles környezetben?
Válasz: Megakadályozza az API-kulcs kliens oldali kitételét, és lehetővé teszi a felhasználó hitelesítését, a fogyasztás korlátozását, valamint a hívások naplózását – három olyan dolgot, amely lehetetlen, ha a böngésző közvetlenül beszél az API-val.
4. Mi a célja a `prompt` paraméternek az átírási API-ban?
Válasz: Hogy a felismerést a várt szókincs felé terelje: tulajdonnevek, márkanevek, szakmai zsargon. Az ott felsorolt kifejezések sokkal pontosabban kerülnek átírásra.
5. Mi a fő befolyásoló tényező a hangügynök észlelt késleltetésében?
Válasz: A végpontok közötti streaming: a hang lejátszása azonnal, ahogy az első töredékek megérkeznek, ahelyett, hogy megvárnánk a teljes választ, valamint a megszakítások kezelése, így a felhasználó bármikor közbeszólhat.