Lydstreaming i begge retninger
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 (den angivne erstatning ergpt-realtime-2.1-mini, hvilket OpenAI TTS-guiden angiver ikke understøttes af/v1/audio/speech: migration af talesyntese flyttes til 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-dupleks tale har GPT-Live 1 været tilgængelig i API’en siden 10. september 2026.
Lydstreaming i begge retninger
Lydstreaming i begge retninger er kernen i Realtime API. Du sender løbende lydbidder fra mikrofonen, og modellen returnerer løbende svarlydbidder. Disse to streams er uafhængige og kan køre samtidigt – hvilket er det, der får samtalen til at føles naturlig.
PCM16-lydformat
Realtime API bruger formatet 24 kHz mono 16-bit PCM. Dette er et rått, ukomprimeret format: hver prøve er et 16-bit heltal med fortegn. Dette valg prioriterer lav latens frem for båndbreddeeffektivitet.
Lydbidder sendes Base64-kodet inden for JSON-events. Hver bid repræsenterer typisk 20 til 100 ms lyd.
Sending af lyd: Mikrofonoptagelse
Sådan optager du fra mikrofonen og streamer lyden:
import asyncio
import sounddevice as sd
import numpy as np
import base64
import json
SAMPLE_RATE = 24000
CHUNK_DURATION_MS = 100
CHUNK_SIZE = int(SAMPLE_RATE * CHUNK_DURATION_MS / 1000)
async def stream_microphone(ws):
"""Optag fra mikrofonen og send bidder til Realtime API."""
loop = asyncio.get_event_loop()
audio_queue = asyncio.Queue()
def audio_callback(indata, frames, time_info, status):
if status:
print(f"Audio warning: {status}")
# Konverter til int16 og sæt i kø
pcm_data = (indata[:, 0] * 32767).astype(np.int16)
loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)
# Start optagelse
stream = sd.InputStream(
samplerate=SAMPLE_RATE,
channels=1,
dtype="float32",
blocksize=CHUNK_SIZE,
callback=audio_callback
)
with stream:
print("Mikrofon aktiv — tal nu...")
while True:
pcm_data = await audio_queue.get()
audio_b64 = base64.b64encode(pcm_data.tobytes()).decode("utf-8")
await ws.send(json.dumps({
"type": "input_audio_buffer.append",
"audio": audio_b64
}))
Lydbufferen på serversiden
Bidder sendt via input_audio_buffer.append akkumuleres i en buffer på serveren. Denne buffer behandles på to måder:
- Automatisk VAD-tilstand (
server_vad): Serveren registrerer, når du holder op med at tale, og commit’er automatisk bufferen. - Manuel tilstand: Du sender eksplicit
input_audio_buffer.commitfor at udløse behandlingen.
# Commit lydbufferen manuelt
await ws.send(json.dumps({
"type": "input_audio_buffer.commit"
}))
# Eller ryd bufferen uden at behandle den
await ws.send(json.dumps({
"type": "input_audio_buffer.clear"
}))
Modtagelse af svarlyd
Lydsvar ankommer i bidder via response.output_audio.delta-events. Du skal dekode og afspille dem løbende:
import pyaudio
async def play_response_audio(ws):
"""Modtag og afspil svarlyd."""
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=SAMPLE_RATE,
output=True,
frames_per_buffer=CHUNK_SIZE
)
try:
async for raw_message in ws:
event = json.loads(raw_message)
if event["type"] == "response.output_audio.delta":
# Dekoder Base64-lydbidden
audio_bytes = base64.b64decode(event["delta"])
player.write(audio_bytes)
elif event["type"] == "response.output_audio.done":
print("Lydsvaret er afsluttet")
elif event["type"] == "response.output_audio_transcript.delta":
# Teksttransskription af svaret
print(event["delta"], end="", flush=True)
finally:
player.stop_stream()
player.close()
pa.terminate()
Komplet applikation: Talesamtale
Sådan samler du optagelse og afspilning til en fuld samtale:
async def conversation_vocale():
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(URL, additional_headers=headers) as ws:
# Vent på session.created
await ws.recv()
# Konfigurer sessionen
await ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"output_modalities": ["audio"],
"instructions": "You are a voice assistant. Respond in English.",
"audio": {
"input": {
"format": {"type": "audio/pcm", "rate": 24000},
"turn_detection": {
"type": "server_vad",
"threshold": 0.5,
"silence_duration_ms": 700
}
},
"output": {
"format": {"type": "audio/pcm", "rate": 24000},
"voice": "marin"
}
}
}
}))
await ws.recv() # session.updated
# Start optagelse og afspilning parallelt
await asyncio.gather(
stream_microphone(ws),
play_response_audio(ws)
)
asyncio.run(conversation_vocale())
Håndtering af samtidige streams
Udfordringen ved streaming i begge retninger er, at du sender og modtager samtidigt på den samme WebSocket. asyncio.gather starter begge coroutines parallelt, men de deler det samme WebSocket-objekt. Biblioteket websockets håndterer denne samtidighed korrekt.
Vigtige pointer
- Lyd overføres som 24 kHz mono 16-bit PCM, Base64-kodet i JSON-events
- Bidder er typisk på 20 til 100 ms lyd for en god balance mellem latens og overhead
- Lydbufferen på serversiden akkumulerer bidder indtil commit (automatisk i VAD-tilstand)
- Afspilning af svar sker bid-for-bid via
response.output_audio.delta asyncio.gathermuliggør samtidig optagelse og afspilning på den samme WebSocket