Straumēta audio reāllaikā
Šajā lapā
Atjauninājums 2026. gada 2. novembrī — Audio modeļi. Vairāki šī kursa modeļi ir novecojuši:
tts-1,tts-1-hdungpt-4o-mini-ttspārtrauks darboties 2027. gada 6. janvārī (pēctecis:gpt-realtime-2.1-mini, ko OpenAI TTS rokasgrāmata norāda kā ** neatbalstītu ar/v1/audio/speech**: balss sintēzes migrācija pāriet uz Realtime API);gpt-realtime,gpt-4o-realtimeun vecie audio modeļi — 2027. gada 20. janvārī (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeun/v1/audio/translations— 2027. gada 26. februārī (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pilndupleksa balsij GPT-Live 1 ir pieejams API kopš 2026. gada 10. septembra. Atjaunināts 2026. gada 3. novembrī: LLM → TTS konveijers iepriekš apstrādāja jebkuru notikumu, kas saturēja laukudelta, tostarp funkciju izsaukumu argumentus vai spriešanas kopsavilkumus; tagad tas filtrē stingri tikairesponse.output_text.delta, proti, faktisko atbildes tekstu.
Straumēta audio reāllaikā
Balsa aģentā gaidīšana, līdz tiek ģenerēts viss audio fails pirms atskaņošanas sākšanas, rada nepieņemamu latentumu. TTS straumēšana ļauj sākt atskaņošanu, tiklīdz ierodas pirmie baiti, samazinot laiku līdz pirmajai atbildei līdz dažiem simtiem milisekunžu.
Straumēšana ar TTS API
TTS API atbalsta straumēšanu dabiski. Gaidot pilnu failu, tu saņem audio pa daļām:
from openai import OpenAI
import pyaudio
client = OpenAI()
def stream_tts_to_speaker(text: str, voice: str = "alloy"):
"""Ģenerē un atskaņo audio straumēšanas režīmā."""
# Inicilizē audio atskaņotāju
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
try:
# Izveido straumēšanas atbildi
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm" # Neapstrādāts PCM tiešai atskaņošanai
) as response:
# Lasī un atskaņo pa daļām
for chunk in response.iter_bytes(chunk_size=4096):
player.write(chunk)
finally:
player.stop_stream()
player.close()
pa.terminate()
stream_tts_to_speaker("Sveiki, šī ir reāllaika straumēšanas atbilde.")
Formāts pcm ir ideāls straumēšanai, jo tam nav nepieciešama dekodēšana: neapstrādātie baiti ir gatavi tūlītējai atskaņošanai.
Latentuma mērīšana
Laiks līdz pirmajam baitam (TTFB) ir galvenais rādītājs straumēšanas veiktspējai:
import time
def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
"""Mēra TTS straumēšanas latentumus."""
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("Sveiki, kā tev iet?")
print(f"TTFB: {metrics['ttfb_ms']}ms, Kopā: {metrics['total_ms']}ms")
Asinhronā straumēšana
Lietotņu servera pusē izmanto asinhrono klientu:
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_tts_async(text: str, voice: str = "alloy"):
"""Asinhrona TTS straumēšana serveriem."""
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)
# Šeit tu nosūtītu daļu klientam, izmantojot WebSocket
yield chunk
# Lietošana FastAPI serverī
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"
)
Iepriekšēja bufera aizpilde
Lai nodrošinātu vienmērīgu atskaņošanu bez pārtraukumiem, uzkrāj nelielu buferi pirms sākšanas:
async def buffered_tts_playback(
text: str,
voice: str = "alloy",
buffer_size: int = 3 # Daļu skaits iepriekšējai ielādei
):
"""TTS atskaņošana ar iepriekš aizpildītu buferi."""
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
# Iztukšo sākotnējo buferi
for buffered_chunk in buffer:
player.write(buffered_chunk)
buffer.clear()
elif playback_started:
player.write(chunk)
# Atskaņo atlikušās daļas
for remaining in buffer:
player.write(remaining)
finally:
player.stop_stream()
player.close()
pa.terminate()
Integrācija ar LLM + TTS konveijeru
Balsa aģentā, kas neizmanto Realtime API, tu vari apvienot LLM straumēšanu ar TTS straumēšanu:
async def llm_to_tts_pipeline(user_message: str):
"""Konveijers: Straumējošs LLM → Reāllaika straumējošs TTS."""
# 1. posms: Uzkrāj LLM atbildi pa teikumiem
sentence_buffer = ""
stream = client.responses.create(
model="gpt-5.6-luna",
input=[{"role": "user", "content": user_message}],
stream=True
)
for event in stream:
# Runājami jābūt tikai atbildes tekstam
if event.type == "response.output_text.delta":
sentence_buffer += event.delta
# Nosaka teikuma beigas
if sentence_buffer.rstrip().endswith((".", "!", "?")):
sentence = sentence_buffer.strip()
sentence_buffer = ""
# 2. posms: Straumē šo teikumu uz TTS
stream_tts_to_speaker(sentence)
# Apstrādā atlikušo buferi
if sentence_buffer.strip():
stream_tts_to_speaker(sentence_buffer.strip())
Galvenās atziņas
- TTS straumēšana samazina TTFB līdz dažiem simtiem milisekunžu, sākot atskaņošanu pirms ģenerēšanas pabeigšanas
- Formāts
pcmir optimāls straumēšanai: nav nepieciešama dekodēšana, tieša atskaņošana - Iepriekšējs buferis ar 2–3 daļām novērš pārtraukumus atskaņošanas sākumā
- Asinhronais klients ir būtisks serveriem, kas apstrādā vairākus vienlaicīgus savienojumus
- Straumējoša LLM un straumējoša TTS kombinēšana ļauj izveidot reaģējošu balsa aģentu bez Realtime API