Reaalajas helivoogedastus
Sellel lehel
Uuendus 2. novembril 2026 – Helimudelid. Selles kursuses on mitu mudelit aegunud:
tts-1,tts-1-hdjagpt-4o-mini-ttslõpetavad töö 6. jaanuaril 2027 (järeltulija:gpt-realtime-2.1-mini, mille OpenAI TTS juhend märgib kui mittetoetatud/v1/audio/speechpoolt: häälesünteesi migratsioon liigub Realtime API-le);gpt-realtime,gpt-4o-realtimeja vanad helimudelid 20. jaanuaril 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeja/v1/audio/translations26. veebruaril 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Täisdupleksse kõne jaoks on GPT-Live 1 olnud API-s saadaval alates 10. septembrist 2026. Uuendatud 3. novembril 2026: LLM → TTS töövoog töötles varem kõiki sündmusi, mis sisaldasid väljadelta, sealhulgas funktsioonikutsude argumente või arutluskäigu kokkuvõtteid; nüüd filtreerib see rangelt ainultresponse.output_text.delta, mis on tegelik vastuse tekst.
Reaalajas helivoogedastus
Hääleagendi puhul toob kogu helifaili genereerimise ootamine enne taasesituse alustamist kaasa vastuvõetamatu latentsuse. TTS-i voogedastus võimaldab sul alustada taasesitust niipea, kui saabuvad esimesed baidid, vähendades esimese vastuseni jõudmise aega mõnele sajale millisekundile.
Voogedastus TTS API-ga
TTS API toetab voogedastust loomupäraselt. Täieliku faili ootamise asemel saad heli tükkidena:
from openai import OpenAI
import pyaudio
client = OpenAI()
def stream_tts_to_speaker(text: str, voice: str = "alloy"):
"""Genereeri ja esita heli voogedastusrežiimis."""
# Algata helimängija
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
try:
# Loo voogedastuse vastus
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm" # Toores PCM otseseks taasesituseks
) as response:
# Loe ja esita tükk haaval
for chunk in response.iter_bytes(chunk_size=4096):
player.write(chunk)
finally:
player.stop_stream()
player.close()
pa.terminate()
stream_tts_to_speaker("Tere, siin on reaalajas voogedastuse vastus.")
Formaat pcm on voogedastuseks ideaalne, kuna see ei vaja dekodeerimist: toored baidid on koheseks esitamiseks valmis.
Latentsuse mõõtmine
Esimese baidini kuluv aeg (TTFB) on voogedastuse jõudluse võtmemõõdik:
import time
def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
"""Mõõda TTS-i voogedastuse latentsust."""
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("Tere, kuidas läheb?")
print(f"TTFB: {metrics['ttfb_ms']}ms, Kokku: {metrics['total_ms']}ms")
Asünkroonne voogedastus
Serveripoolsete rakenduste jaoks kasuta asünkroonset klienti:
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_tts_async(text: str, voice: str = "alloy"):
"""Asünkroonne TTS-i voogedastus serveritele."""
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)
# Siin saadaksid tüki kliendile WebSocketi kaudu
yield chunk
# Kasutamine FastAPI serveris
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"
)
Eeltäidetud puhver
Sujuva taasesituse tagamiseks ilma katkestusteta kogune väike puhver enne algust:
async def buffered_tts_playback(
text: str,
voice: str = "alloy",
buffer_size: int = 3 # Eellaaditavate tükkide arv
):
"""TTS-i taasesitus eeltäidetud puhvriga."""
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
# Tühjenda algne puhver
for buffered_chunk in buffer:
player.write(buffered_chunk)
buffer.clear()
elif playback_started:
player.write(chunk)
# Esita ülejäänud tükid
for remaining in buffer:
player.write(remaining)
finally:
player.stop_stream()
player.close()
pa.terminate()
Integreerimine LLM + TTS töövoogu
Mitte-Realtime hääleagendis saad kombineerida LLM-i voogedastuse TTS-i voogedastusega:
async def llm_to_tts_pipeline(user_message: str):
"""Töövoog: Voogedastav LLM → Reaalajas voogedastav TTS."""
# Faas 1: Kogu LLM-i vastus lausetena
sentence_buffer = ""
stream = client.responses.create(
model="gpt-5.6-luna",
input=[{"role": "user", "content": user_message}],
stream=True
)
for event in stream:
# Rääkida tuleks ainult vastuse teksti
if event.type == "response.output_text.delta":
sentence_buffer += event.delta
# Tuvasta lause lõpp
if sentence_buffer.rstrip().endswith((".", "!", "?")):
sentence = sentence_buffer.strip()
sentence_buffer = ""
# Faas 2: Voogedasta see lause TTS-i
stream_tts_to_speaker(sentence)
# Töötle ülejäänud puhver
if sentence_buffer.strip():
stream_tts_to_speaker(sentence_buffer.strip())
Peamised punktid
- TTS-i voogedastus vähendab TTFB-i mõnele sajale millisekundile, alustades taasesitust enne genereerimise lõppu
- Formaat
pcmon voogedastuseks optimaalne: dekodeerimist pole vaja, otsene taasesitus - 2–3 tüki suurune eeltäidetud puhver hoiab ära katkestused taasesituse alguses
- Asünkroonne klient on hädavajalik serveritele, mis haldavad mitut samaaegset ühendust
- Voogedastava LLM-i ja voogedastava TTS-i kombineerimine võimaldab luua reageerimisvõimelist hääleagenti ilma Realtime API-t kasutamata