Produktion: Skalning och övervakning
På denna sida
Uppdaterad 2 november 2026 — Ljudmodeller. Flera modeller i denna kurs är avvecklade:
tts-1,tts-1-hdochgpt-4o-mini-ttsslutar fungera den 6 januari 2027 (ersättning:gpt-realtime-2.1-mini, vilket OpenAI:s TTS-guide anger inte stöds av/v1/audio/speech: migrering av talgenerering måste ske via Realtime API);gpt-realtime,gpt-4o-realtimeoch äldre ljudmodeller den 20 januari 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeoch/v1/audio/translationsden 26 februari 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). För full-duplex-röst har GPT-Live 1 funnits tillgängligt i API:t sedan 10 september 2026.
Uppdaterad 3 november 2026. Kostnadshantering rymdes tidigare i en mening; den speglar nu den faktureringsmodell som beskrivs av OpenAI (fakturering per svar, konversation returneras varje varv, ljud räknas i tokens, automatisk cachelagring, transkribering faktureras separat) och trunkering via
retention_ratio, vars format verifierades motopenaiSDK-typer version 3.42.1. Källa: Cost optimization.
Produktion: Skalning och övervakning
Att gå från en prototyp för röstagent till en pålitlig, skalbar produktionstjänst kräver noggrann uppmärksamhet på infrastruktur, övervakning och felhantering. Denna sista lektion täcker de operativa grundstenarna för att driftsätta en röstagent under verkliga förhållanden.
Produktionsarkitektur
I produktion körs röstagenten bakom en lastbalanserare och en pool av arbetare:
Lastbalanserare (nginx / HAProxy)
Fördelar inkommande WebSocket-anslutningar över arbetare. Stöder sticky sessions för att behålla affinitet.
Arbetare (FastAPI + uvicorn)
Varje arbetare hanterar flera samtidiga Realtime-sessioner tack vare asyncio.
Databas (PostgreSQL)
Lagrar konversationsloggar, metrik och agentkonfiguration.
Övervakning (Prometheus + Grafana)
Samlar in realtidsmetrik: latens, antal sessioner, fel, kostnader.
Hantering av samtidiga sessioner
Varje WebSocket-anslutning upprätthåller en Realtime API-session. Antalet samtidiga sessioner begränsas av dina hastighetsbegränsningar hos OpenAI och dina arbetares kapacitet:
import asyncio
from dataclasses import dataclass
@dataclass
class SessionManager:
"""Hanterar samtidiga Realtime API-sessioner."""
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):
"""Skapar en ny session med kontroll av samtidighet."""
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):
"""Stänger en session korrekt."""
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)
Strukturerad loggning
Logga varje interaktion för felsökning och regelefterlevnad:
import logging
import json
from datetime import datetime
class ConversationLogger:
"""Strukturerad loggare för röstkonversationer."""
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):
"""Sparar hela loggen till databasen."""
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
Exponera metrik för övervakning i realtid:
from prometheus_client import Counter, Histogram, Gauge, start_http_server
# Viktiga metrik
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
)
# Starta metrikservern
start_http_server(9090)
Kostnadshantering
Enligt OpenAI:s guide Cost optimization faktureras en Realtime-konversationssession per svar, i in- och utdatatokens för text, ljud och bilder. Tre mekanismer driver det mesta av fakturan:
- Hela konversationen skickas tillbaka till modellen vid varje svar: senare varv kostar mer än tidigare.
- Ljud räknas i tokens: 1 token per 100 ms användarljud, 1 token per 50 ms assistentljud.
- Prompt-cachelagring appliceras automatiskt: så länge början av konversationen inte ändras, faktureras den till den reducerade cachelagrade token-taxan. Att ändra eller ta bort ett äldre element “bryter” cachen från den punkten och framåt.
Indatatranskribering, om aktiverad, faktureras separat till sin egen modells taxa: gpt-transcribe debiteras efter duration, läst från händelsen conversation.item.input_audio_transcription.completed. Förbrukningen för varje svar visas i response.done, under response.usage (total_tokens, input_tokens, output_tokens, plus uppdelningen för text, ljud, bild och cache).
För att begränsa kontextstorleken – och därmed kostnaden för senare varv – accepterar sessionen en trunkeringsregel: bortom gränsen tas de äldsta meddelandena bort. Med retention_ratio satt under 1 tar servern bort något mer än nödvändigt, vilket sprider ut trunkeringarna och bevarar cachen:
await ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"truncation": {
"type": "retention_ratio",
"retention_ratio": 0.8,
"token_limits": {"post_instructions": 8000},
},
},
}))
Avvägningen: en agent som behåller mindre kontext glömmer snabbare. Komplettera detta med sessionsgränser i din kod:
class CostController:
"""Kontrollerar kostnader för en Realtime-session."""
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 ""
Felhantering i produktion
async def production_event_loop(ws, logger, cost_ctrl):
"""Robust händelseloop för produktion."""
cost_ctrl.start()
try:
async for raw in ws:
event = json.loads(raw)
t = event["type"]
# Kontrollera kostnadsgränser
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()
Viktiga punkter
- Produktionsarkitekturen separerar lastbalanserare, asyncio-arbetare, databas och övervakning
- En
SessionManagermed en semaphore kontrollerar antalet samtidiga sessioner - Strukturerad JSON-loggning möjliggör felsökning och regelefterlevnad (inspelning av konversationer)
- Prometheus-metrik (TTFA, duration, tokens, fel) är avgörande för den dagliga driften
CostControllerbegränsar sessionsduration och tokens för att förhindra överskridanden av budgeten
Testa dina kunskaper
Fem frågor som täcker hela röstkedjan, från WebSocket till driftsättning i produktion.
1. Varför använder Realtime API WebSocket istället för HTTP-förfrågningar?
Svar: Eftersom en persistent, tvåvägsanslutning låter dig strömma mikrofonljud och ta emot svar kontinuerligt, utan att betala overheaden för att upprätta en förfrågan för varje utbyte. Detta är förutsättningen för konversation med låg latens.
2. Vad måste du skicka omedelbart efter `session.created`, och varför?
Svar: session.update, omedelbart: det är här du konfigurerar röst, instruktioner, verktyg och ljudformat. tills detta meddelande skickats körs sessionen med standardvärden.
3. Varför är en proxyserver avgörande i produktion?
Svar: Den förhindrar att API-nyckeln exponeras i klienten, och den låter dig autentisera användaren, begränsa förbrukningen och logga anrop – tre saker som är omöjliga om webbläsaren pratar direkt med API:t.
4. Vad är syftet med parametern `prompt` i transkriberings-API:t?
Svar: Att styra igenkänningen mot förväntad vokabulär: egennamn, varumärken, domänspecifik jargong. Termer du listar där transkriberas mycket mer korrekt.
5. Vad är den huvudsakliga hävstången för upplevd latens i en röstagent?
Svar: End-to-end-strömning: att spela upp ljud så snart de första fragmenten anländer istället för att vänta på hela svaret, och att hantera avbrott så att användaren kan klippa in när som helst.