Gamyba: mastelio keitimas ir stebėjimas
Šiame puslapyje
Atnaujinta 2026 m. lapkričio 2 d. — Garso modeliai. Keli šio kurso modeliai yra pasenę:
tts-1,tts-1-hdirgpt-4o-mini-ttsnustos veikti 2027 m. sausio 6 d. (pakaitalas:gpt-realtime-2.1-mini, kuris, kaip nurodyta OpenAI TTS gide, nepalaikomas per/v1/audio/speech: kalbos sintezės migracija turi vykti per Realtime API);gpt-realtime,gpt-4o-realtimeir senieji garso modeliai – 2027 m. sausio 20 d. (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeir/v1/audio/translations– 2027 m. vasario 26 d. (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pilno dublekso (full-duplex) balsui GPT-Live 1 API yra prieinamas nuo 2026 m. rugsėjo 10 d.
Atnaujinta 2026 m. lapkričio 3 d. Išlaidų valdymas anksčiau tilpdavo į vieną sakinį; dabar jis atspindi OpenAI aprašytą atsiskaitymo modelį (apmokėjimas už kiekvieną atsakymą, pokalbis grąžinamas kiekvienu ėjimu, garsas skaičiuojamas tokenais, automatinis talpyklos naudojimas, transkripcija apmokestinama atskirai) ir sutrumpinimą per
retention_ratio, kurio formatas buvo patikrintas pagalopenaiSDK tipų versiją 3.42.1. Šaltinis: Išlaidų optimizavimas.
Gamyba: mastelio keitimas ir stebėjimas
Perėjimas nuo balso agento prototipo prie patikimos, mastelį keičiančios gamybinės paslaugos reikalauja didelio dėmesio infrastruktūrai, stebėjimui ir klaidų valdymui. Šioje paskutinėje pamokoje aptariami operaciniai pagrindai, būtini diegiant balso agentą realiomis sąlygomis.
Gamybinė architektūra
Gamyboje balso agentas veikia už apkrovos balansuoklio ir darbuotojų baseino:
Apkrovos balansuoklis (nginx / HAProxy)
Paskirsto gaunamus WebSocket ryšius tarp darbuotojų. Palaiko lipnias sesijas (sticky sessions) ryšiui išlaikyti.
Darbuotojai (FastAPI + uvicorn)
Kiekvienas darbuotojas, dėka asyncio, tvarko kelias vienu metu vykstančias Realtime sesijas.
Duomenų bazė (PostgreSQL)
Saugo pokalbių žurnalus, metrikas ir agento konfigūraciją.
Stebėjimas (Prometheus + Grafana)
Renka realiuoju laiku gaunamas metrikas: delsą, sesijų skaičių, klaidas, išlaidas.
Vienalaikių sesijų valdymas
Kiekvienas WebSocket ryšys palaiko vieną Realtime API sesiją. Vienalaikių sesijų skaičių riboja tavo OpenAI greičio apribojimai ir darbuotojų pajėgumai:
import asyncio
from dataclasses import dataclass
@dataclass
class SessionManager:
"""Valdo vienalaikes Realtime API sesijas."""
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):
"""Sukuria naują sesiją su lygiagretumo valdymu."""
async with self.semaphore:
if session_id in self.active_sessions:
raise ValueError(f"Sesija {session_id} jau aktyvi")
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):
"""Tinkamai užbaigia sesiją."""
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)
Struktūruotas registravimas (Logging)
Registruok kiekvieną sąveiką derinimui ir atitikties reikalavimams:
import logging
import json
from datetime import datetime
class ConversationLogger:
"""Struktūruotas balso pokalbių registruotojas."""
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):
"""Išsaugo visą žurnalą duomenų bazėje."""
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 metrikos
Pateik metrikas stebėjimui realiuoju laiku:
from prometheus_client import Counter, Histogram, Gauge, start_http_server
# Pagrindinės metrikos
sessions_active = Gauge(
"voice_sessions_active",
"Aktyvių balso sesijų skaičius"
)
session_duration = Histogram(
"voice_session_duration_seconds",
"Balso sesijų trukmė",
buckets=[30, 60, 120, 300, 600, 1800]
)
response_latency = Histogram(
"voice_response_latency_ms",
"Atsakymo delsa (kalbos pabaiga → pirmas garsas)",
buckets=[200, 400, 600, 800, 1000, 1500, 2000, 3000]
)
errors_total = Counter(
"voice_errors_total",
"Bendras klaidų skaičius",
["error_type"]
)
tokens_used = Counter(
"voice_tokens_total",
"Suvartoti tokenai",
["type"] # input_audio, output_audio, input_text, output_text
)
# Paleidžia metrikų serverį
start_http_server(9090)
Išlaidų valdymas
Pagal OpenAI Išlaidų optimizavimo gidą, Realtime pokalbio sesija apmokestinama už kiekvieną atsakymą, įvesties ir išvesties tokenais tekstui, garsui ir vaizdams. Trys mechanizmai lemia didžiąją sąskaitos dalį:
- Visas pokalbis siunčiamas modeliui atgal su kiekvienu atsakymu: vėlesni ėjimai kainuoja daugiau nei ankstesni.
- Garsas skaičiuojamas tokenais: 1 tokenas už 100 ms naudotojo garso, 1 tokenas už 50 ms asistento garso.
- Promptų talpykla (caching) taikoma automatiškai: kol pokalbio pradžia nesikeičia, ji apmokestinama sumažintu talpyklos tokenų tarifu. Senesnio elemento modifikavimas arba ištrynimas „sulaužo“ talpyklą nuo to momento.
Įvesties transkripcija, jei įjungta, apmokestinama atskirai pagal savo modelio tarifą: gpt-transcribe apmokestinamas pagal trukmę, nuskaitytą iš conversation.item.input_audio_transcription.completed įvykio. Vartojimas kiekvienam atsakymui rodomas response.done dalyje, skiltyje response.usage (total_tokens, input_tokens, output_tokens, plius suskirstymas tekstui, garsui, vaizdui ir talpyklai).
Norint apriboti konteksto dydį – ir taip vėlesnių ėjimų kainą – sesija priima sutrumpinimo taisyklę: viršijus ribą, seniausi pranešimai pašalinami. Nustačius retention_ratio mažiau nei 1, serveris pašalina šiek tiek daugiau nei būtina, taip retindamas sutrumpinimus ir išsaugodamas talpyklą:
await ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"truncation": {
"type": "retention_ratio",
"retention_ratio": 0.8,
"token_limits": {"post_instructions": 8000},
},
},
}))
Kompromisas: agentas, kuris išlaiko mažiau konteksto, greičiau pamiršta. Papildyk tai sesijų limitais savo kode:
class CostController:
"""Valdo Realtime sesijos išlaidas."""
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"Ši sesija baigsis po {int(remaining)} sekundžių."
return ""
Gamybinis klaidų valdymas
async def production_event_loop(ws, logger, cost_ctrl):
"""Patikimas įvykių ciklas gamybai."""
cost_ctrl.start()
try:
async for raw in ws:
event = json.loads(raw)
t = event["type"]
# Tikrina išlaidų limitus
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": "Sesija artėja prie savo trukmės ribos."}]
}
}))
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()
Svarbiausi punktai
- Gamybinė architektūra atskiria apkrovos balansuoklį, asyncio darbuotojus, duomenų bazę ir stebėjimą
SessionManagersu semaforu valdo vienalaikių sesijų skaičių- JSON struktūruotas registravimas leidžia derinti ir užtikrinti atitiktį (pokalbių įrašymas)
- Prometheus metrikos (TTFA, trukmė, tokenai, klaidos) yra būtinos kasdienei veiklai
CostControllerriboja sesijos trukmę ir tokenus, kad būtų išvengta biudžeto viršijimo
Patikrink savo žinias
Penki klausimai, apimantys visą balso grandinę – nuo WebSocket iki diegimo gamyboje.
1. Kodėl Realtime API naudoja WebSocket vietoj HTTP užklausų?
Atsakymas: Nes nuolatinis, dvipusis ryšys leidžia transliuoti mikrofono garsą ir nuolat gauti atsakymus, nemokant papildomai už kiekvieno mainų užklausos nustatymą. Tai yra būtina sąlyga mažos delsos pokalbiui.
2. Ką turi siųsti iškart po `session.created` ir kodėl?
Atsakymas: session.update, nedelsiant: čia konfigūruoji balsą, instrukcijas, įrankius ir garso formatą. Kol šis pranešimas neišsiųstas, sesija veikia numatytosiomis reikšmėmis.
3. Kodėl tarpinis serveris (proxy) yra būtinas gamyboje?
Atsakymas: Jis neleidžia atskleisti API rakto kliente ir leidžia autentifikuoti naudotoją, riboti vartojimą bei registruoti kvietimus – trijų dalykų, neįmanomų, jei naršyklė kalbėtų tiesiai su API.
4. Kokia yra `prompt` parametro paskirtis transkripcijos API?
Atsakymas: Nukreipti atpažinimą link tikėtinos žodynos: tikrinių daiktavardžių, prekių ženklų, srities žargono. Ten išvardyti terminai transkribuojami daug tiksliau.
5. Koks yra pagrindinis svertas, darantis įtaką suvokiamai delsai balso agente?
Atsakymas: End-to-end srautinis perdavimas: garso leidimas iškart, kai tik atkeliauja pirmieji fragmentai, vietoj laukimo iki pilno atsakymo, ir pertraukimų valdymas, kad naudotojas galėtų įsiterpti bet kuriuo metu.