Produktion: Skalering og overvågning
På denne side
Opdateret 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset:
tts-1,tts-1-hdoggpt-4o-mini-ttsophører med at fungere den 6. januar 2027 (erstatning:gpt-realtime-2.1-mini, som OpenAI’s TTS-guide angiver ikke understøttes af/v1/audio/speech: migration af talesyntese skal ske via Realtime API);gpt-realtime,gpt-4o-realtimeog ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeog/v1/audio/translationsden 26. februar 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Til fuld-duplex tale har GPT-Live 1 været tilgængelig i API’en siden 10. september 2026.
Opdateret 3. november 2026. Omkostningsstyring passede tidligere ind i én sætning; det afspejler nu den faktureringsmodel, som OpenAI beskriver (fakturering pr. svar, samtale returneres hver omgang, audio tælles i tokens, automatisk caching, transskription faktureres separat) og trunkering via
retention_ratio, hvis format blev verificeret modopenaiSDK-typer version 3.42.1. Kilde: Cost optimization.
Produktion: Skalering og overvågning
At gå fra en prototype på en taleagent til en pålidelig, skalerbar produktionstjeneste kræver tæt fokus på infrastruktur, overvågning og fejlhåndtering. Denne sidste lektion dækker de operationelle essentials for at deploye en taleagent under reelle forhold.
Produktionsarkitektur
I produktion kører taleagenten bag en load balancer og en pulje af workers:
Load Balancer (nginx / HAProxy)
Fordeler indgående WebSocket-forbindelser på tværs af workers. Understøtter sticky sessions for at opretholde affinitet.
Workers (FastAPI + uvicorn)
Hver worker håndterer flere samtidige Realtime-sessioner takket være asyncio.
Database (PostgreSQL)
Gemmer samtalelogs, metrikker og agentkonfiguration.
Overvågning (Prometheus + Grafana)
Indsamler realtidsmetrikker: latency, antal sessioner, fejl, omkostninger.
Håndtering af samtidige sessioner
Hver WebSocket-forbindelse vedligeholder en Realtime API-session. Antallet af samtidige sessioner er begrænset af dine OpenAI-rate limits og dine workers’ kapacitet:
import asyncio
from dataclasses import dataclass
@dataclass
class SessionManager:
"""Håndterer samtidige 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):
"""Opretter en ny session med kontrol af samtidighed."""
async with self.semaphore:
if session_id in self.active_sessions:
raise ValueError(f"Session {session_id} allerede aktiv")
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):
"""Lukker 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)
Struktureret logning
Log hver interaktion til fejlfinding og compliance:
import logging
import json
from datetime import datetime
class ConversationLogger:
"""Struktureret logger til talesamtaler."""
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):
"""Gemmer den komplette log i 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-metrikker
Eksponér metrikker til overvågning i realtid:
from prometheus_client import Counter, Histogram, Gauge, start_http_server
# Nøglemetrikker
sessions_active = Gauge(
"voice_sessions_active",
"Antal aktive talesessioner"
)
session_duration = Histogram(
"voice_session_duration_seconds",
"Varighed af talesessioner",
buckets=[30, 60, 120, 300, 600, 1800]
)
response_latency = Histogram(
"voice_response_latency_ms",
"Svarlatency (slutning af tale → første audio)",
buckets=[200, 400, 600, 800, 1000, 1500, 2000, 3000]
)
errors_total = Counter(
"voice_errors_total",
"Samlet antal fejl",
["error_type"]
)
tokens_used = Counter(
"voice_tokens_total",
"Forbrugte tokens",
["type"] # input_audio, output_audio, input_text, output_text
)
# Start metrikserveren
start_http_server(9090)
Omkostningsstyring
Ifølge OpenAI’s guide Cost optimization faktureres en Realtime-samtale pr. svar, i input- og output-tokens for tekst, audio og billeder. Tre mekanismer driver størstedelen af regningen:
- Hele samtalen sendes tilbage til modellen ved hvert svar: senere omganger koster mere end tidligere.
- Audio tælles i tokens: 1 token pr. 100 ms bruger-audio, 1 token pr. 50 ms assistant-audio.
- Prompt-caching gælder automatisk: Så længe begyndelsen af samtalen ikke ændres, faktureres den til den reducerede cachede token-sats. At modificere eller slette et ældre element „bryder” cachen fra det punkt og frem.
Input-transskription, hvis aktiveret, faktureres separat til sin egen models sats: gpt-transcribe opkræves efter varighed, aflæst fra conversation.item.input_audio_transcription.completed-begivenheden. Forbruget for hvert svar fremgår af response.done under response.usage (total_tokens, input_tokens, output_tokens, plus opdelingen for tekst, audio, billede og cache).
For at begrænse kontekststørrelsen – og dermed omkostningerne ved senere omganger – accepterer sessionen en trunkeringsregel: ud over grænsen droppes de ældste beskeder. Med retention_ratio sat under 1 fjerner serveren lidt mere end nødvendigt, hvilket spreder trunkeringerne og bevarer 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},
},
},
}))
Afvæjningen: En agent, der beholder mindre kontekst, glemmer hurtigere. Supplér dette med sessionsgrænser i din kode:
class CostController:
"""Styrer omkostninger for 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"Denne session afsluttes om {int(remaining)} sekunder."
return ""
Fejlhåndtering i produktion
async def production_event_loop(ws, logger, cost_ctrl):
"""Robust begivenhedsløkke til produktion."""
cost_ctrl.start()
try:
async for raw in ws:
event = json.loads(raw)
t = event["type"]
# Tjek omkostningsgræ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": "Sessionen nærmer sig sin varighedsgrænse."}]
}
}))
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()
Vigtige pointer
- Produktionsarkitektur adskiller load balancer, asyncio-workers, database og overvågning
- En
SessionManagermed en semaphore styrer antallet af samtidige sessioner - JSON-struktureret logning muliggør fejlfinding og compliance (optagelse af samtaler)
- Prometheus-metrikker (TTFA, varighed, tokens, fejl) er essentielle for den daglige drift
CostControllerbegrænser sessionsvarighed og tokens for at forhindre budgetoverskridelser
Test din viden
Fem spørgsmål, der dækker hele talekæden, fra WebSocket til produktions-deployment.
1. Hvorfor bruger Realtime API WebSocket i stedet for HTTP-forespørgsler?
Svar: Fordi en vedvarende, tovejsforbindelse lader dig streame mikrofon-audio og modtage svar kontinuerligt uden at betale overheadet ved at etablere en forespørgsel for hver udveksling. Dette er forudsætningen for samtaler med lav latency.
2. Hvad skal du sende umiddelbart efter `session.created`, og hvorfor?
Svar: session.update, med det samme: her konfigurerer du stemme, instrukser, værktøjer og audioformat. Indtil denne besked er sendt, kører sessionen med standardværdier.
3. Hvorfor er en proxyserver essentiel i produktion?
Svar: Den forhindrer eksponering af API-nøglen i klienten, og den lader dig autentificere brugeren, begrænse forbrug og logge kald – tre ting, der er umulige, hvis browseren taler direkte med API’en.
4. Hvad er formålet med parameteren `prompt` i transskriptions-API'en?
Svar: At styre genkendelsen mod forventet ordforråd: egennavne, brands, fagjargon. Termer, du lister der, transskriberes langt mere præcist.
5. Hvad er den vigtigste løftestang for oplevet latency i en taleagent?
Svar: End-to-end streaming: at afspille audio, så snart de første fragmenter ankommer, i stedet for at vente på det fulde svar, og at håndtere afbrydelser, så brugeren kan bryde ind når som helst.