Spring til hovedindhold
Dansk— Vælg et sprog
Menu

WebSocket-arkitekturen for Realtime API

Lektion 1 af 18 Opdateret 3. november 2026 Udvikler
På denne side
  1. WebSocket-arkitekturen for Realtime API
  2. Tre stemmearkitekturer i 2026
  3. WebRTC, WebSocket eller SIP
  4. WebSocket kontra REST: Hvorfor dette valg?
  5. Etablering af en WebSocket-forbindelse
  6. Arkitektur for Realtime-applikationer
  7. Vigtige pointer

Opdateret 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset: tts-1, tts-1-hd og gpt-4o-mini-tts ophø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: migrationen af talesyntese flytter til Realtime API); gpt-realtime, gpt-4o-realtime og ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe og /v1/audio/translations den 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. Tillæg 3. november 2026: afsnit om OpenAI’s tre stemmearkitekturer (GPT-Live, Realtime API, behandlingskæde) og valg af transport (WebRTC, WebSocket, SIP), baseret på guiderne Voice agents, Audio and voice og Getting started with the Realtime API; maksimal sessionsvarighed: 60 minutter (Realtime conversations).

WebSocket-arkitekturen for Realtime API

OpenAI’s Realtime API repræsenterer et fundamentalt paradigmeskift i måden, du interagerer med sprogmodeller på. I modsætning til traditionelle REST-API’er, der opererer på en anmodning-svar-cyklus, bruger Realtime API WebSocket-protokollen til at etablere en vedvarende, todvejsforbindelse mellem din applikation og modellen.

Denne arkitektur muliggør udveksling af lyd i realtid: Du sender lyd, modellen behandler den og svarer verbalt med lav latency, hvor den springer mellemtrin som transskription eller tekst-til-tale over. Dette er en af de centrale byggesten for konversationelle taleagenter og kernen i dette kursus.

Tre stemmearkitekturer i 2026

Før du åbner en WebSocket, skal du placere Realtime API i kontekst sammen med OpenAI’s andre løsninger. Guiden Voice agents skelner mellem tre tilgange:

ArkitekturBedst tilHvorfor vælge den
GPT-LiveFuld-duplex samtaler med en separat backendStemmemodellen lytter, mens den taler, og delegerer ræsonnement og værktøjsbrug til en backend efter dit valg; bevarer din eksisterende tekstagent intakt
Realtime APITale, ræsonnement og værktøjer i én sessionEn enkelt model fortolker lyd, beslutter hvad der skal gøres, og taler svaret
BehandlingskædeGranulær kontrol over hvert trinTransskription, derefter tekstagent, derefter talesyntese: Du inspicerer eller transformerer tekst mellem trinene og udskifter hver komponent uafhængigt

Til nye applikationer med talekonversationer anbefaler OpenAI’s side Audio and voice nu at starte med GPT-Live. Realtime API forbliver det rigtige udgangspunkt, når agenten skal passe ind i én enkelt session, der understøtter brugerafbrydelser, hurtigt første lydsvar, naturlig turtagning og direkte værktøjskald. Behandlingskæden fungerer bedst, når hvert trin skal forblive synligt: bevarelse af transskripter, håndhævelse af regler før agenten svarer, eller udsendelse af tale først efter validering af svaret.

Dette kursus fokuserer på Realtime API og behandlingskæden, hvis komponenter (transskription, talesyntese) dækkes i efterfølgende afsnit.

WebRTC, WebSocket eller SIP

Dit valg af transport afhænger af, hvor lyden stammer fra. Ifølge dokumentationen: Brug WebRTC til browserlyd med en ephemeral klientnøgle genereret af din server; WebSocket til lyd-pipelines på serversiden; SIP til telefonopkald. En kontrolforbindelse på serversiden tillader også en betroet backend at observere og styre en mediesession. Denne lektion detaljerer WebSocket, som er den enkleste måde at forstå udvekslede begivenheder på; i en browser bør du foretrække WebRTC. En Realtime-session varer højst 60 minutter.

WebSocket kontra REST: Hvorfor dette valg?

I en traditionel REST-arkitektur kræver hver interaktion en komplet HTTP-anmodning: åbning af en TCP-forbindelse, TLS-forhandling, sending af headers, venten på svaret og lukning af forbindelsen. Til lyd i realtid er dette overhead uacceptabelt.

Kriterium REST (Responses API) WebSocket (Realtime API)
Latency 200–500 ms pr. anmodning < 50 ms efter forbindelse
Retning Kun klient → server Samtidig todvejs
Forbindelse Ny til hver anmodning Vedvarende (session)
Lyd Hele filen kræves Streaming blok for blok

WebSocket-protokollen holder en kanal åbent kontinuerligt. Når den først er etableret, kan klient og server sende beskeder når som helst uden at vente på, at den anden part bliver færdig.

Etablering af en WebSocket-forbindelse

Sådan etablerer du en forbindelse til Realtime API i Python:

import asyncio
import websockets
import json

OPENAI_API_KEY = "sk-..."
URL = "wss://api.openai.com/v1/realtime?model=gpt-realtime-2.1"

async def connect_realtime():
    headers = {
        "Authorization": f"Bearer {OPENAI_API_KEY}"
    }

    async with websockets.connect(URL, additional_headers=headers) as ws:
        print("Connected to Realtime API")

        # Modtag velkomstbegivenheden
        response = await ws.recv()
        event = json.loads(response)
        print(f"Type: {event['type']}")
        # → "session.created"

        # Hold forbindelsen åben
        await asyncio.Future()

asyncio.run(connect_realtime())

Forbindelses-URL’en inkluderer modellen som en query-parameter. Siden API’en nåede general availability, er kun autentificeringsheadern påkrævet – headern OpenAI-Beta: realtime=v1 fra beta-fasen er fjernet.

Grænseflade noteret 5. august 2026 — Realtime API udvikler sig (modeller, begivenhedsnavne, sessionsformat): Når du er i tvivl, så tjek den officielle dokumentation.

Arkitektur for Realtime-applikationer

En applikation, der bruger Realtime API, følger en lagdelt arkitektur:

1

Lyd-lag (optagelse/afspilning)

Optager mikrofonen, afspiller lydsvar. Bruger PyAudio, sounddevice eller Web Audio API i browseren.

2

WebSocket-lag (transport)

Håndterer den vedvarende forbindelse, encoder/decoder JSON-begivenheder, håndterer genforbindelser.

3

Applikations-lag (forretningslogik)

Orkestrerer samtalen, håndterer kontekst, kalder værktøjer, behandler resultater.

4

Server-lag (valgfri proxy)

I produktion beskytter en mellemliggende server API-nøglen og tilføjer forretningslogik på serversiden.

Proxy-serverens rolle

Under udvikling kan du forbinde din applikation direkte til Realtime API. I produktion er en proxy-server essentiel for at:

  • Beskytte din API-nøgle — eksponér den aldrig på klientsiden
  • Autentificere dine brugere — verificér tokens før åbning af sessionen
  • Kontrollere omkostninger — begræns sessionsvarighed og token-forbrug
  • Logge interaktioner — til fejlfinding og overholdelse af regler
# Forenklet eksempel på en WebSocket-proxy med FastAPI
from fastapi import FastAPI, WebSocket
import websockets

app = FastAPI()

@app.websocket("/ws/realtime")
async def proxy_realtime(client_ws: WebSocket):
    await client_ws.accept()

    headers = {"Authorization": f"Bearer {OPENAI_API_KEY}"}

    async with websockets.connect(URL, additional_headers=headers) as openai_ws:
        async def forward_to_openai():
            async for message in client_ws.iter_text():
                await openai_ws.send(message)

        async def forward_to_client():
            async for message in openai_ws:
                await client_ws.send_text(message)

        await asyncio.gather(forward_to_openai(), forward_to_client())

Vigtige pointer

  • Tre stemmearkitekturer hos OpenAI: GPT-Live (anbefalet til nye konversations-apps), Realtime API (tale, ræsonnement og værktøjer i én session) og kæden transskription → agent → syntese
  • WebRTC til browserlyd, WebSocket til server-pipelines, SIP til telefoni; sessioner varer højst 60 minutter
  • Realtime API bruger WebSocket til todvejskommunikation med lav latency
  • Forbindelsen er vedvarende: én åbning for hele konversationssessionen
  • Lagdelt arkitektur adskiller lyd, transport, forretningslogik og server-proxy
  • I produktion er en proxy-server essentiel for sikkerhed og omkostningskontrol
  • Protokollen er begivenhedsdrevet: hver besked er et JSON-objekt med et type-felt