Produkcija: Skaliranje in spremljanje
Na tej strani
Posodobljeno 2. novembra 2026 — Zvočni modeli. Nekateri modeli v tem tečaju so zastareli:
tts-1,tts-1-hdingpt-4o-mini-ttsbodo prenehali delovati 6. januarja 2027 (zamenjava:gpt-realtime-2.1-mini, ki ga vodnik OpenAI za TTS navaja kot nepodprtega z/v1/audio/speech: selitev sinteze govora mora potekati prek Realtime API);gpt-realtime,gpt-4o-realtimein starejši zvočni modeli 20. januarja 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribein/v1/audio/translations26. februarja 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Za polno duplexni glas je GPT-Live 1 na voljo v API-ju od 10. septembra 2026.
Posodobljeno 3. novembra 2026. Upravljanje stroškov je bilo prej zajeto v enem stavku; zdaj odraža obračunski model, ki ga opisuje OpenAI (obračun na odgovor, pogovor vrnjen ob vsakem koraku, zvok štet v žetone, samodejno predpomnjenje, prepis obračunan ločeno) in obrezovanje prek
retention_ratio, katerega format je bil preverjen glede na tipe SDKopenairazličice 3.42.1. Vir: Optimizacija stroškov.
Produkcija: Skaliranje in spremljanje
Prehod od prototipa glasovnega agenta do zanesljive, skalabilne produkcijske storitve zahteva veliko pozornosti do infrastrukture, spremljanja in obravnave napak. Ta zadnja lekcija pokriva operativne osnove za uvedbo glasovnega agenta v realnih pogojih.
Produkcijska arhitektura
V produkciji glasovni agent teče za uravnotežilnikom obremenitve in bazenom delavcev:
Uravnotežilnik obremenitve (nginx / HAProxy)
Porazdeljuje dohodne WebSocket povezave med delavce. Podpira lepljive seje za ohranjanje afinitete.
Delavci (FastAPI + uvicorn)
Vsak delavec hkrati obravnava več sej Realtime zahvaljujoč asyncio.
Baza podatkov (PostgreSQL)
Shranjuje dnevnike pogovorov, metrike in konfiguracijo agenta.
Spremljanje (Prometheus + Grafana)
Zbira metrike v realnem času: zakasnitev, število sej, napake, stroški.
Upravljanje sočasnih sej
Vsaka povezava WebSocket vzdržuje sejo Realtime API. Število sočasnih sej je omejeno z vašimi omejitvami hitrosti OpenAI in zmogljivostjo vaših delavcev:
import asyncio
from dataclasses import dataclass
@dataclass
class SessionManager:
"""Upravlja sočasne seje 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):
"""Ustvari novo sejo z nadzorom sočasnosti."""
async with self.semaphore:
if session_id in self.active_sessions:
raise ValueError(f"Seja {session_id} je že aktivna")
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):
"""Pravilno zapre sejo."""
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)
Strukturirano beleženje
Zabeleži vsako interakcijo za razhroščevanje in skladnost:
import logging
import json
from datetime import datetime
class ConversationLogger:
"""Strukturirani beležnik za glasovne pogovore."""
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):
"""Trajno shrani celoten dnevnik v bazo podatkov."""
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)
)
Metrike Prometheus
Izpostavi metrike za spremljanje v realnem času:
from prometheus_client import Counter, Histogram, Gauge, start_http_server
# Ključne metrike
sessions_active = Gauge(
"voice_sessions_active",
"Število aktivnih glasovnih sej"
)
session_duration = Histogram(
"voice_session_duration_seconds",
"Trajanje glasovnih sej",
buckets=[30, 60, 120, 300, 600, 1800]
)
response_latency = Histogram(
"voice_response_latency_ms",
"Zakasnitev odziva (konec govora → prvi zvok)",
buckets=[200, 400, 600, 800, 1000, 1500, 2000, 3000]
)
errors_total = Counter(
"voice_errors_total",
"Skupno število napak",
["error_type"]
)
tokens_used = Counter(
"voice_tokens_total",
"Porabljeni žetoni",
["type"] # input_audio, output_audio, input_text, output_text
)
# Zaženi strežnik metrik
start_http_server(9090)
Upravljanje stroškov
Glede na vodnik OpenAI Optimizacija stroškov se seja pogovora Realtime obračunava na odgovor, v vhodnih in izhodnih žetonih za besedilo, zvok in slike. Trije mehanizmi poganjajo večino računa:
- Celoten pogovor je poslan nazaj modelu z vsakim odgovorom: kasnejši koraki stanejo več kot zgodnejši.
- Zvok je štet v žetone: 1 žeton na 100 ms uporabnikovega zvoka, 1 žeton na 50 ms zvoka asistenta.
- Predpomnjenje pozivov se uporablja samodejno: dokler se začetek pogovora ne spremeni, se obračuna po znižani stopnji za predpomnjene žetone. Sprememba ali brisanje starejšega elementa „zlomi” predpomnilnik od te točke naprej.
Vhodni prepis, če je omogočen, se obračunava ločeno po lastni tarifi modela: gpt-transcribe se zaračuna po trajanju, prebranem iz dogodka conversation.item.input_audio_transcription.completed. Poraba za vsak odgovor se pojavi v response.done, pod response.usage (total_tokens, input_tokens, output_tokens, plus razčlenitev za besedilo, zvok, sliko in predpomnilnik).
Za omejitev velikosti konteksta – in s tem stroškov kasnejših korakov – seja sprejme pravilo obrezovanja: prek meje se najstarejša sporočila zavržejo. Z nastavitvijo retention_ratio pod 1 strežnik odstrani nekoliko več, kot je potrebno, kar razmakne obrezovanja in ohrani predpomnilnik:
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, ki obdrži manj konteksta, hitreje pozabi. To dopolni z omejitvami sej v svoji kodi:
class CostController:
"""Nadzira stroške za sejo 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"Ta seja se bo končala čez {int(remaining)} sekund."
return ""
Obravnava napak v produkciji
async def production_event_loop(ws, logger, cost_ctrl):
"""Robustna zanka dogodkov za produkcijo."""
cost_ctrl.start()
try:
async for raw in ws:
event = json.loads(raw)
t = event["type"]
# Preveri omejitve stroškov
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": "Seja se približuje svoji časovni omejitvi."}]
}
}))
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()
Ključne ugotovitve
- Produkcijska arhitektura ločuje uravnotežilnik obremenitve, delavce asyncio, bazo podatkov in spremljanje
SessionManagers semaforjem nadzira število sočasnih sej- Strukturirano beleženje JSON omogoča razhroščevanje in skladnost (snemanje pogovorov)
- Metrike Prometheus (TTFA, trajanje, žetoni, napake) so bistvene za vsakodnevno delovanje
CostControlleromejuje trajanje sej in žetone, da prepreči presežke proračuna
Preveri svoje znanje
Pet vprašanj, ki pokrivajo celoten glasovni niz, od WebSocket do uvedbe v produkcijo.
1. Zakaj Realtime API uporablja WebSocket namesto zahtev HTTP?
Odgovor: Ker trajna, dvosmerna povezava omogoča pretakanje zvoka mikrofona in neprekinjeno prejemanje odgovorov, ne da bi plačevali stroške vzpostavljanja zahteve za vsako izmenjavo. To je predpogoj za pogovor z nizko zakasnitvijo.
2. Kaj moraš poslati takoj po `session.created` in zakaj?
Odgovor: session.update, takoj: tu konfiguriraš glas, navodila, orodja in zvočni format. Dokler to sporočilo ni poslano, seja teče z privzetimi vrednostmi.
3. Zakaj je posredniški strežnik v produkciji nujen?
Odgovor: Preprečuje razkrivanje ključa API v odjemalcu in ti omogoča avtentikacijo uporabnika, omejitev porabe in beleženje klicev – tri stvari, ki so nemogoče, če brskalnik govori neposredno z API-jem.
4. Kakšen je namen parametra `prompt` v API-ju za prepis?
Odgovor: Usmerjanje prepoznavanja proti pričakovanemu besedišču: lastna imena, blagovne znamke, strokovni žargon. Izrazi, ki jih tam navedeš, so prepisani veliko natančneje.
5. Kaj je glavni vzvod za zaznano zakasnitev pri glasovnem agentu?
Odgovor: Pretakanje od konca do konca: predvajanje zvoka, takoj ko prispejo prvi fragmenti, namesto čakanja na celoten odgovor, in obravnava prekinitev, tako da lahko uporabnik kadarkoli poseže vmes.