Kétirányú audio streaming
Ezen az oldalon
Frissítve: 2026. november 2. — Audió modellek. A tanfolyam több modellje elavult: a
tts-1,tts-1-hdés agpt-4o-mini-tts2027. január 6-án megszűnik működni (a javasolt utód agpt-realtime-2.1-mini, amelyet az OpenAI TTS útmutatója szerint a/v1/audio/speechnem támogat: a beszédszintézis migrációja a Realtime API-ra helyeződik át); agpt-realtime,gpt-4o-realtimeés a legacy audió modellek 2027. január 20-án válnak elavulttá (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5); awhisper-1,gpt-4o-transcribeés a/v1/audio/translationsendpointok 2027. február 26-án szűnnek meg (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). A teljes duplex hangalapú kommunikációhoz a GPT-Live 1 már 2026. szeptember 10. óta elérhető az API-ban.
Kétirányú audio streaming
A kétirányú audio streaming a Realtime API szíve-lelke. Folyamatosan küldesz audió darabkákat a mikrofonról, és a modell folyamatosan visszaadja a válasz audió darabkáit. Ez a két adatfolyam független, és egyszerre működhet – ettől lesz a beszélgetés természetes hatású.
PCM16 audió formátum
A Realtime API 24 kHz-es, mono, 16 bites PCM formátumot használ. Ez egy nyers, tömörítetlen formátum: minden minta egy 16 bites előjeles egész szám. Ez a választás a kis késleltetést helyezi előtérbe a sávszélesség-hatékonysággal szemben.
Az audió darabkákat Base64-kódolással küldöd JSON eseményeken belül. Egy darabka jellemzően 20–100 ms hosszúságú audiót reprezentál.
Audió küldése: Mikrofon rögzítése
Így rögzítheted a mikrofont és streamelheted az audiót:
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):
"""Rögzíti a mikrofont és darabkákat küld a Realtime API-nak."""
loop = asyncio.get_event_loop()
audio_queue = asyncio.Queue()
def audio_callback(indata, frames, time_info, status):
if status:
print(f"Audio warning: {status}")
# Átalakítás int16-ra és sorba állítás
pcm_data = (indata[:, 0] * 32767).astype(np.int16)
loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)
# Rögzítés indítása
stream = sd.InputStream(
samplerate=SAMPLE_RATE,
channels=1,
dtype="float32",
blocksize=CHUNK_SIZE,
callback=audio_callback
)
with stream:
print("Mikrofon aktív — most beszélhetsz...")
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
}))
A szerveroldali audió puffer
Az input_audio_buffer.append segítségével küldött darabkák felhalmozódnak egy szerveroldali pufferben. Ezt a puffert kétféleképpen dolgozza fel a rendszer:
- Automatikus VAD mód (
server_vad): A szerver érzékeli, amikor abbahagyod a beszédet, és automatikusan véglegesíti (commit) a puffert. - Kézi mód: Expliciten elküldöd az
input_audio_buffer.commitparancsot a feldolgozás elindításához.
# Audió puffer kézi véglegesítése
await ws.send(json.dumps({
"type": "input_audio_buffer.commit"
}))
# Vagy a puffer törlése feldolgozás nélkül
await ws.send(json.dumps({
"type": "input_audio_buffer.clear"
}))
Válasz audió fogadása
A válasz audió darabkákban érkezik meg a response.output_audio.delta eseményeken keresztül. Ezeket folyamatosan dekódolnod és le kell játszanod:
import pyaudio
async def play_response_audio(ws):
"""Fogadja és lejátsza a válasz audiót."""
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":
# Base64 audió darabka dekódolása
audio_bytes = base64.b64decode(event["delta"])
player.write(audio_bytes)
elif event["type"] == "response.output_audio.done":
print("Audió válasz befejeződött")
elif event["type"] == "response.output_audio_transcript.delta":
# A válasz szöveges átírása
print(event["delta"], end="", flush=True)
finally:
player.stop_stream()
player.close()
pa.terminate()
Teljes alkalmazás: Hangalapú beszélgetés
Így állíthatod össze a rögzítést és a lejátszást egy teljes beszélgetéshez:
async def conversation_vocale():
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(URL, additional_headers=headers) as ws:
# Várakozás a session.created eseményre
await ws.recv()
# Munkamenet konfigurálása
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
# Rögzítés és lejátszás indítása párhuzamosan
await asyncio.gather(
stream_microphone(ws),
play_response_audio(ws)
)
asyncio.run(conversation_vocale())
Egyidejű adatfolyamok kezelése
A kétirányú streaming kihívása, hogy ugyanazon a WebSocket kapcsolaton egyszerre küldesz és fogadsz adatot. Az asyncio.gather mindkét koroutint párhuzamosan indítja el, de ugyanazt a WebSocket objektumot használják. A websockets könyvtár helyesen kezeli ezt az egyidejűséget.
Főbb megállapítások
- Az audiót 24 kHz-es, mono, 16 bites PCM formátumban továbbítjuk, JSON eseményekben Base64-kódolással
- A darabkák jellemzően 20–100 ms hosszúságúak, ami jó kompromisszum a késleltetés és a túlterhelés között
- A szerveroldali audió puffer felhalmozza a darabkákat a véglegesítésig (VAD módban ez automatikus)
- A válasz lejátszása darabról darabra történik a
response.output_audio.deltaeseményeken keresztül - Az
asyncio.gatherlehetővé teszi a rögzítés és a lejátszás egyidejű végrehajtását ugyanazon a WebSocket kapcsolaton