Flux audio în timp real
Pe această pagină
Actualizare 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 (succesor:gpt-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 API-ul Realtime);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. Actualizat 3 noiembrie 2026: Pipeline-ul LLM → TTS procesa anterior orice eveniment care conținea un câmpdelta, inclusiv argumente de apelare a funcțiilor sau rezumate de raționament; acum filtrează strict pentruresponse.output_text.delta, textul real al răspunsului.
Flux audio în timp real
În cazul unui agent vocal, așteptarea generării întregului fișier audio înainte de a începe redarea introduce o latență inacceptabilă. Fluxul TTS vă permite să începeți redarea imediat ce sosesc primii octeți, reducând timpul până la primul răspuns la câteva sute de milisecunde.
Flux cu API-ul TTS
API-ul TTS suportă nativ fluxul de date. În loc să așteptați fișierul complet, primiți audio în blocuri:
from openai import OpenAI
import pyaudio
client = OpenAI()
def stream_tts_to_speaker(text: str, voice: str = "alloy"):
"""Generează și redă audio în mod flux."""
# Inițializează playerul audio
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
try:
# Creează răspunsul flux
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm" # PCM brut pentru redare directă
) as response:
# Citește și redă bloc cu bloc
for chunk in response.iter_bytes(chunk_size=4096):
player.write(chunk)
finally:
player.stop_stream()
player.close()
pa.terminate()
stream_tts_to_speaker("Hello, here is a real-time streaming response.")
Formatul pcm este ideal pentru flux deoarece nu necesită decodare: octeții brute sunt gata de redare imediat.
Măsurarea latenței
Timpul până la primul octet (TTFB) este metrica cheie pentru performanța fluxului:
import time
def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
"""Măsoară latențele fluxului TTS."""
start_time = time.time()
first_byte_time = None
total_bytes = 0
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm"
) as response:
for chunk in response.iter_bytes(chunk_size=4096):
if first_byte_time is None:
first_byte_time = time.time()
total_bytes += len(chunk)
end_time = time.time()
return {
"ttfb_ms": round((first_byte_time - start_time) * 1000),
"total_ms": round((end_time - start_time) * 1000),
"total_bytes": total_bytes,
"audio_duration_s": round(total_bytes / (24000 * 2), 2)
}
metrics = measure_tts_latency("Hello, how are you?")
print(f"TTFB: {metrics['ttfb_ms']}ms, Total: {metrics['total_ms']}ms")
Flux asincron
Pentru aplicațiile lato-server, utilizați clientul asincron:
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_tts_async(text: str, voice: str = "alloy"):
"""Flux TTS asincron pentru servere."""
chunks = []
async with async_client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm"
) as response:
async for chunk in response.iter_bytes(chunk_size=4096):
chunks.append(chunk)
# Aici, ați trimite blocul către client prin WebSocket
yield chunk
# Utilizare într-un server FastAPI
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
app = FastAPI()
@app.get("/tts/stream")
async def tts_stream(text: str, voice: str = "alloy"):
return StreamingResponse(
stream_tts_async(text, voice),
media_type="audio/pcm"
)
Pre-umplerea tamponului
Pentru a asigura o redare fluidă fără întreruperi, acumulați un mic tampon înainte de a începe:
async def buffered_tts_playback(
text: str,
voice: str = "alloy",
buffer_size: int = 3 # Număr de blocuri de preîncărcat
):
"""Redare TTS cu tampon de pre-umplere."""
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
buffer = []
playback_started = False
try:
async with async_client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm"
) as response:
async for chunk in response.iter_bytes(chunk_size=4096):
buffer.append(chunk)
if not playback_started and len(buffer) >= buffer_size:
playback_started = True
# Golire tampon inițial
for buffered_chunk in buffer:
player.write(buffered_chunk)
buffer.clear()
elif playback_started:
player.write(chunk)
# Redă blocurile rămase
for remaining in buffer:
player.write(remaining)
finally:
player.stop_stream()
player.close()
pa.terminate()
Integrarea cu un pipeline LLM + TTS
Într-un agent vocal non-Realtime, puteți combina fluxul LLM cu fluxul TTS:
async def llm_to_tts_pipeline(user_message: str):
"""Pipeline: Flux LLM → Flux TTS în timp real."""
# Faza 1: Acumulare răspuns LLM pe propoziții
sentence_buffer = ""
stream = client.responses.create(
model="gpt-5.6-luna",
input=[{"role": "user", "content": user_message}],
stream=True
)
for event in stream:
# Doar textul răspunsului trebuie rostit
if event.type == "response.output_text.delta":
sentence_buffer += event.delta
# Detectare sfârșit de propoziție
if sentence_buffer.rstrip().endswith((".", "!", "?")):
sentence = sentence_buffer.strip()
sentence_buffer = ""
# Faza 2: Flux acestei propoziții către TTS
stream_tts_to_speaker(sentence)
# Procesare tampon rămas
if sentence_buffer.strip():
stream_tts_to_speaker(sentence_buffer.strip())
Puncte cheie
- Fluxul TTS reduce TTFB la câteva sute de milisecunde prin începerea redării înainte de finalizarea generării
- Formatul
pcmeste optim pentru flux: nu necesită decodare, redare directă - Un tampon de pre-umplere de 2–3 blocuri previne întreruperile la începutul redării
- Clientul asincron este esențial pentru serverele care gestionează multiple conexiuni simultane
- Combinarea fluxului LLM și a fluxului TTS permite un agent vocal reactiv fără API-ul Realtime