Flux audio bidirecțional
Pe această pagină
Actualizat la 2 noiembrie 2026 — Modele audio. Mai multe modele din acest curs sunt depreciate:
tts-1,tts-1-hdșigpt-4o-mini-ttsvor înceta să funcționeze la 6 ianuarie 2027 (înlocuitorul indicat estegpt-realtime-2.1-mini, pe care ghidul OpenAI TTS precizează că nu este suportat de/v1/audio/speech: migrarea sintezei vocale se mută către Realtime API);gpt-realtime,gpt-4o-realtimeși modelele audio legacy la 20 ianuarie 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeși/v1/audio/translationsla 26 februarie 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pentru voce full-duplex, GPT-Live 1 este disponibil în API din 10 septembrie 2026.
Flux audio bidirecțional
Fluxul audio bidirecțional reprezintă nucleul Realtime API. Trimiteți continuu fragmente audio de la microfon, iar modelul returnează continuu fragmente audio de răspuns. Aceste două fluxuri sunt independente și pot opera simultan – ceea ce conferă conversației un caracter natural.
Format audio PCM16
Realtime API utilizează formatul PCM mono pe 16 biți la 24 kHz. Acesta este un format brut, necomprimat: fiecare eșantion este un întreg semnat pe 16 biți. Această alegere prioritizează latența scăzută în detrimentul eficienței lățimii de bandă.
Fragmentele audio sunt trimise codificate Base64 în cadrul evenimentelor JSON. Fiecare fragment reprezintă, de obicei, între 20 și 100 ms de audio.
Trimiterea audio: Captarea microfonului
Iată cum să capturați microfonul și să transmiteți fluxul audio:
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):
"""Capturează microfonul și trimite fragmente către Realtime API."""
loop = asyncio.get_event_loop()
audio_queue = asyncio.Queue()
def audio_callback(indata, frames, time_info, status):
if status:
print(f"Avertisment audio: {status}")
# Convertire în int16 și adăugare în coadă
pcm_data = (indata[:, 0] * 32767).astype(np.int16)
loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)
# Start captare
stream = sd.InputStream(
samplerate=SAMPLE_RATE,
channels=1,
dtype="float32",
blocksize=CHUNK_SIZE,
callback=audio_callback
)
with stream:
print("Microfon activ — vorbiți acum...")
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
}))
Bufferul audio lato-server
Fragmentele trimise prin input_audio_buffer.append se acumulează într-un buffer pe server. Acest buffer este procesat în două moduri:
- Mod VAD automat (
server_vad): Serverul detectează când încetați să vorbiți și validează automat bufferul. - Mod manual: Trimiteți explicit
input_audio_buffer.commitpentru a declanșa procesarea.
# Validare manuală a bufferului audio
await ws.send(json.dumps({
"type": "input_audio_buffer.commit"
}))
# Sau golire buffer fără procesare
await ws.send(json.dumps({
"type": "input_audio_buffer.clear"
}))
Recepcionarea audio de răspuns
Răspunsurile audio sosesc fragmentat prin evenimente response.output_audio.delta. Trebuie să le decodați și să le redați continuu:
import pyaudio
async def play_response_audio(ws):
"""Recepționează și redă audio de răspuns."""
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":
# Decodare fragment audio Base64
audio_bytes = base64.b64decode(event["delta"])
player.write(audio_bytes)
elif event["type"] == "response.output_audio.done":
print("Răspuns audio terminat")
elif event["type"] == "response.output_audio_transcript.delta":
# Transcriere text a răspunsului
print(event["delta"], end="", flush=True)
finally:
player.stop_stream()
player.close()
pa.terminate()
Aplicație completă: Conversație vocală
Iată cum să asamblați captarea și redarea pentru o conversație completă:
async def conversation_vocale():
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(URL, additional_headers=headers) as ws:
# Așteptare session.created
await ws.recv()
# Configurare sesiune
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
# Lansare captare și redare în paralel
await asyncio.gather(
stream_microphone(ws),
play_response_audio(ws)
)
asyncio.run(conversation_vocale())
Gestionarea fluxurilor concurente
Provocarea fluxului bidirecțional constă în trimiterea și recepționarea simultană pe același WebSocket. asyncio.gather lansează ambele coroutine în paralel, dar acestea partajează același obiect WebSocket. Biblioteca websockets gestionează corect această concurență.
Puncte cheie
- Audio este transmis ca PCM mono pe 16 biți la 24 kHz, codificat Base64 în evenimente JSON
- Fragmentele au de obicei 20–100 ms de audio pentru un compromis optim latență/suprasarcină
- Bufferul audio lato-server acumulează fragmente până la validare (automat în mod VAD)
- Redarea răspunsului se face fragment cu fragment prin
response.output_audio.delta asyncio.gatherpermite captarea și redarea simultane pe același WebSocket