Streaming af lyd i realtid
På denne side
Opdatering 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset:
tts-1,tts-1-hdoggpt-4o-mini-ttsophører med at fungere den 6. januar 2027 (efterfølger:gpt-realtime-2.1-mini, som OpenAI TTS-guiden angiver ikke understøttes af/v1/audio/speech: migration af talesyntese flyttes til Realtime API);gpt-realtime,gpt-4o-realtimeog ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeog/v1/audio/translationsden 26. februar 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Til fuld-duplex tale har GPT-Live 1 været tilgængelig i API’en siden 10. september 2026. Opdateret 3. november 2026: LLM → TTS-pipelinen behandlede tidligere enhver begivenhed, der indeholdt etdelta-felt, herunder funktionskaldsargumenter eller resuméer af ræsonnementer; den filtrerer nu strengt efterresponse.output_text.delta, som er selve svarteksten.
Streaming af lyd i realtid
I en taleagent introducerer ventetid på, at hele lydfilen genereres før afspilning starter, en uacceptabel latenstid. TTS-streaming lader dig starte afspilningen, så snart de første bytes ankommer, hvilket reducerer tiden til første svar til få hundrede millisekunder.
Streaming med TTS API’en
TTS API’en understøtter streaming nativt. I stedet for at vente på den komplette fil, modtager du lyden i bidder:
from openai import OpenAI
import pyaudio
client = OpenAI()
def stream_tts_to_speaker(text: str, voice: str = "alloy"):
"""Generér og afspil lyd i streaming-tilstand."""
# Initialisér lydafspilleren
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
try:
# Opret streaming-svaret
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm" # Rå PCM til direkte afspilning
) as response:
# Læs og afspil bid for bid
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.")
Formatet pcm er ideelt til streaming, da det ikke kræver afkodning: de rå bytes er klar til afspilning med det samme.
Måling af latenstid
Time to First Byte (TTFB) er den centrale metrik for streaming-ydeevne:
import time
def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
"""Mål TTS-streaming-latenser."""
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")
Asynkron streaming
Til server-side-applikationer skal du bruge den asynkrone klient:
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_tts_async(text: str, voice: str = "alloy"):
"""Asynkron TTS-streaming til 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)
# Her ville du sende bitten til klienten via WebSocket
yield chunk
# Brug i en 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"
)
Forudfyldning af buffer
For at sikre jævn afspilning uden huller skal du akkumulere en lille buffer, før du starter:
async def buffered_tts_playback(
text: str,
voice: str = "alloy",
buffer_size: int = 3 # Antal bidder der skal indlæses på forhånd
):
"""TTS-afspilning med en forudfyldt buffer."""
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øm den indledende buffer
for buffered_chunk in buffer:
player.write(buffered_chunk)
buffer.clear()
elif playback_started:
player.write(chunk)
# Afspil resterende bidder
for remaining in buffer:
player.write(remaining)
finally:
player.stop_stream()
player.close()
pa.terminate()
Integration med en LLM + TTS-pipeline
I en taleagent, der ikke bruger Realtime API, kan du kombinere LLM-streaming med TTS-streaming:
async def llm_to_tts_pipeline(user_message: str):
"""Pipeline: Streaming LLM → Real-time streaming TTS."""
# Fase 1: Akkumulér LLM-svar sætning for sætning
sentence_buffer = ""
stream = client.responses.create(
model="gpt-5.6-luna",
input=[{"role": "user", "content": user_message}],
stream=True
)
for event in stream:
# Kun svartekst skal tales
if event.type == "response.output_text.delta":
sentence_buffer += event.delta
# Registrér slutningen af en sætning
if sentence_buffer.rstrip().endswith((".", "!", "?")):
sentence = sentence_buffer.strip()
sentence_buffer = ""
# Fase 2: Stream denne sætning til TTS
stream_tts_to_speaker(sentence)
# Behandl resterende buffer
if sentence_buffer.strip():
stream_tts_to_speaker(sentence_buffer.strip())
Vigtige pointer
- TTS-streaming reducerer TTFB til få hundrede millisekunder ved at starte afspilningen, før genereringen er færdig
- Formatet
pcmer optimalt til streaming: ingen afkodning krævet, direkte afspilning - En forudfyldt buffer på 2–3 bidder forhindrer huller i starten af afspilningen
- Den asynkrone klient er essentiel for servere, der håndterer flere samtidige forbindelser
- Kombination af streaming-LLM og streaming-TTS muliggør en responsiv taleagent uden Realtime API