Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Produktion: Skalning och övervakning

Lektion 18 av 18 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Produktion: Skalning och övervakning
  2. Produktionsarkitektur
  3. Hantering av samtidiga sessioner
  4. Strukturerad loggning
  5. Prometheus-metrik
  6. Kostnadshantering
  7. Felhantering i produktion
  8. Viktiga punkter
  9. Testa dina kunskaper

Uppdaterad 2 november 2026 — Ljudmodeller. Flera modeller i denna kurs är avvecklade: tts-1, tts-1-hd och gpt-4o-mini-tts slutar 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-realtime och äldre ljudmodeller den 20 januari 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe och /v1/audio/translations den 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 mot openai SDK-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:

1

Lastbalanserare (nginx / HAProxy)

Fördelar inkommande WebSocket-anslutningar över arbetare. Stöder sticky sessions för att behålla affinitet.

2

Arbetare (FastAPI + uvicorn)

Varje arbetare hanterar flera samtidiga Realtime-sessioner tack vare asyncio.

3

Databas (PostgreSQL)

Lagrar konversationsloggar, metrik och agentkonfiguration.

4

Ö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 SessionManager med 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
  • CostController begrä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.