Tootmine: skaleerimine ja jälgimine
Sellel lehel
Uuendatud 2. novembril 2026 – Helimudelid. Selles kursuses on mitu mudelit aegunud:
tts-1,tts-1-hdjagpt-4o-mini-ttslõpetavad töö 6. jaanuaril 2027 (asendaja:gpt-realtime-2.1-mini, mida OpenAI TTS-i juhend kirjeldab kui mittetoetatud teenuse/v1/audio/speechpoolt: kõnesünteesi migratsioon peab toimuma läbi Realtime API);gpt-realtime,gpt-4o-realtimeja vanad helimudelid 20. jaanuaril 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeja/v1/audio/translations26. veebruaril 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Täisdupleks-hääle jaoks on GPT-Live 1 olnud API-s saadaval alates 10. septembrist 2026.
Uuendatud 3. novembril 2026. Kulude haldamine mahtus varem ühte lausesse; nüüd peegeldab see OpenAI kirjeldatud arveldusmudelit (arveldamine vastuse kohta, vestluse tagastamine igal pöördel, heli lugemine tokeniteks, automaatne vahemällu salvestamine, transkriptsiooni eraldi arveldamine) ja kärpimist parameetri
retention_ratiokaudu, mille formaati kontrollitiopenaiSDK tüüpide versiooni 3.42.1 põhjal. Allikas: Kulude optimeerimine.
Tootmine: skaleerimine ja jälgimine
Üleminek hääleagendi prototüübilt usaldusväärsele ja skaleeritavale tootmisteenusele nõuab põhjalikku tähelepanu taristule, jälgimisele ja vigade käsitlemisele. See viimane õppetund käsitleb hääleagendi reaalses keskkonnas kasutuselevõtuks vajalikke operatiivseid põhielemente.
Tootmisarhitektuur
Tootmises töötab hääleagent koormusjaoturi ja töötajate (workers) kogumi taga:
Koormusjaotur (nginx / HAProxy)
Jagab sissetulevad WebSocketi ühendused töötajate vahel. Toetab kleepuvaid seansse (sticky sessions) afiinsuse säilitamiseks.
Töötajad (FastAPI + uvicorn)
Iga tötleja haldab tänu asyncio-le mitut samaaegset Realtime'i seanssi.
Andmebaas (PostgreSQL)
Salvestab vestluslogisid, mõõdikuid ja agendi konfiguratsiooni.
Jälgimine (Prometheus + Grafana)
Kogub reaalajas mõõdikuid: latentsus, seansside arv, vead, kulud.
Samaaegsete seansside haldamine
Iga WebSocketi ühendus hoiab üleval ühte Realtime API seanssi. Samaaegsete seansside arvu piiravad sinu OpenAI kiirusepiirangud ja töötajate võimsus:
import asyncio
from dataclasses import dataclass
@dataclass
class SessionManager:
"""Haldab samaaegseid Realtime API seansse."""
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):
"""Loob uue seansi koos samaaegsuse kontrolliga."""
async with self.semaphore:
if session_id in self.active_sessions:
raise ValueError(f"Seanss {session_id} on juba aktiivne")
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):
"""Sulgeb seansi korrektselt."""
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)
Struktureeritud logimine
Logi iga interaktsioon silumiseks ja nõuetele vastavuse tagamiseks:
import logging
import json
from datetime import datetime
class ConversationLogger:
"""Struktureeritud logija häälevestlustele."""
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):
"""Salvestab täieliku logi andmebaasi."""
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)
)
Prometheusi mõõdikud
Avalda mõõdikud reaalajas jälgimiseks:
from prometheus_client import Counter, Histogram, Gauge, start_http_server
# Põhimõõdikud
sessions_active = Gauge(
"voice_sessions_active",
"Aktiivsete hääleseansside arv"
)
session_duration = Histogram(
"voice_session_duration_seconds",
"Hääleseansside kestus",
buckets=[30, 60, 120, 300, 600, 1800]
)
response_latency = Histogram(
"voice_response_latency_ms",
"Vastuse latentsus (kõne lõpp → esimene heli)",
buckets=[200, 400, 600, 800, 1000, 1500, 2000, 3000]
)
errors_total = Counter(
"voice_errors_total",
"Vigade koguarv",
["error_type"]
)
tokens_used = Counter(
"voice_tokens_total",
"Tarbitud tokenid",
["type"] # input_audio, output_audio, input_text, output_text
)
# Käivita mõõdikute server
start_http_server(9090)
Kulude haldamine
Vastavalt OpenAI Kulude optimeerimise juhendile arveldatakse Realtime’i vestlusseanssi vastuse kohta, sisendi ja väljundi tokenite kaupa teksti, heli ja piltide jaoks. Arvet mõjutavad enim kolm mehhanismi:
- Kogu vestlus saadetakse mudelile tagasi iga vastusega: hilisemad pöörded maksavad rohkem kui varasemad.
- Heli loetakse tokeniteks: 1 token iga 100 ms kasutaja heli kohta, 1 token iga 50 ms assistendi heli kohta.
- Sisendi vahemällu salvestamine (prompt caching) toimib automaatselt: seni, kuni vestluse algus ei muutu, arveldatakse seda vähendatud vahemällu salvestatud tokenite määraga. Vanema elemendi muutmine või kustutamine „katkestab“ vahemälu sellest punktist edasi.
Sisendi transkriptsioon, kui see on lubatud, arveldatakse eraldi vastava mudeli hinnakirja alusel: gpt-transcribe eest tasutakse kestuse põhjal, mis loetakse sündmusest conversation.item.input_audio_transcription.completed. Iga vastuse tarbimine ilmub välja response.done alla, väljale response.usage (total_tokens, input_tokens, output_tokens, pluss jaotus teksti, heli, pildi ja vahemälu jaoks).
Konteksti suuruse – ja seeläbi hilisemate pöörete kulude – piiramiseks aktsepteerib seanss kärpimisreeglit: ülempiiri ületamisel visatakse vanimad sõnumid minna. Kui retention_ratio on seatud alla 1, eemaldab server veidi rohkem kui vajalik, mis suurendab kärpimiste vahelisi pause ja säilitab vahemälu:
await ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"truncation": {
"type": "retention_ratio",
"retention_ratio": 0.8,
"token_limits": {"post_instructions": 8000},
},
},
}))
Kompromiss: vähem konteksti säilitav agent unustab kiiremini. Täienda seda seansi piirangutega oma koodis:
class CostController:
"""Kontrollib Realtime'i seansi kulusid."""
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"See seanss lõpeb {int(remaining)} sekundi pärast."
return ""
Tootmise veakäsitlus
async def production_event_loop(ws, logger, cost_ctrl):
"""Tugev sündmuste tsükkel tootmiseks."""
cost_ctrl.start()
try:
async for raw in ws:
event = json.loads(raw)
t = event["type"]
# Kontrolli kulupiire
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": "Seanss läheneb oma kestuse piirile."}]
}
}))
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()
Peamised punktid
- Tootmisarhitektuur eraldab koormusjaoturi, asyncio töötajad, andmebaasi ja jälgimise
SessionManagerkoos semaforiga kontrollib samaaegsete seansside arvu- JSON-struktuuriga logimine võimaldab silumist ja nõuetele vastavust (vestluse salvestamine)
- Prometheusi mõõdikud (TTFA, kestus, tokenid, vead) on igapäevaseks toimimiseks hädavajalikud
CostControllerpiirab seansi kestust ja tokenite arvu, et vältida eelarve ületamist
Testi oma teadmisi
Viis küsimust, mis hõlmavad kogu hääleahelat alates WebSocketist kuni tootmisse paigutamiseni.
1. Miks kasutab Realtime API WebSocketit HTTP-päringute asemel?
Vastus: Sest püsiv kahepoolne ühendus võimaldab edastada mikrofoni heli voogu ja saada vastuseid pidevalt, ilma et iga vahetuse jaoks peaks maksmas ühenduse loomise lisakulu. See on madala latentsusega vestluse eeldus.
2. Mida pead saatma kohe pärast `session.created` ja miks?
Vastus: session.update, viivitamatult: siin konfigureerid hääle, juhised, tööriistad ja helivormingu. Enne selle sõnumi saatmist töötab seanss vaikeväärtustega.
3. Miks on puhverserver (proxy) tootmises hädavajalik?
Vastus: See takistab API võtme avalikustamist kliendis ja võimaldab kasutajat autentida, tarbimist piirata ning kõnesid logida – kolm asja, mis on võimatud, kui brauser suhtleb API-ga otse.
4. Mis on parameetri `prompt` eesmärk transkriptsiooni API-s?
Vastus: Suunata äratundmist oodatava sõnavara poole: pärisnimed, kaubamärgid, valdkonna žargoon. Sinna loetletud termineid transkribeeritakse palju täpsemalt.
5. Mis on hääleagendi tajutava latentsuse peamine hoob?
Vastus: Otsene voogedastus (end-to-end streaming): heli esitamine niipea, kui esimesed fragmendid saabuvad, selle asemel et oodata tervet vastust, ning katkestuste käsitlemine, et kasutaja saaks igal ajal vahele astuda.