Telefónia integráció (Twilio és társai)
Ezen az oldalon
Frissítve: 2026. november 3. a Realtime API dokumentációja alapján: a G.711 μ-law formátum neve
audio/pcmu(a korábbi szöveg ag711_ulawnevet említette, ami a béta verzió elnevezése volt). Forrás: Realtime API.
2026. november 2-i frissítés — Hangmodellek. A tanfolyam számos modellje elavult: a
tts-1,tts-1-hdés agpt-4o-mini-ttsmodellek 2027. január 6-án megszűnnek működni (a javasolt utód agpt-realtime-2.1-mini, amelyet az OpenAI TTS útmutatója szerint a/v1/audio/speechvégpont nem támogat: a beszédszintézis migrációját kizárólag a Realtime API-n keresztül kell végrehajtani); agpt-realtime,gpt-4o-realtimeés a legacy hangmodellek 2027. január 20-án válnak elavulttá (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5); awhisper-1,gpt-4o-transcribeés a/v1/audio/translationsvégpontok pedig 2027. február 26-án (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). A teljes duplex hangkommunikációhoz a GPT-Live 1 már 2026. szeptember 10. óta elérhető az API-ban.
Telefónia integráció (Twilio és társai)
Egy hangügynök akkor válik igazán hasznossá, ha telefonon is elérhető. A Twilio, a LiveKit és a Daily gibi felhőalapú telefónia-platformok lehetővé teszik, hogy a Realtime API-t összekapcsold a globális telefonhálózattal. A felhasználó felhív egy számot, az ügynököd pedig valós időben válaszol.
Telefónia architektúra
A telefónia integráció egy réteget illeszt a telefonhálózat és a Realtime API közé:
Bejövő hívás → Twilio
A felhasználó felhív egy telefonszámot. A Twilio fogadja a hívást, és webhookot küld a szerverednek.
Szervered → Médiafolyam
A szervered TwiML utasításokkal válaszol, amelyek megnyitnak egy kétirányú Médiafolyam WebSocket kapcsolatot.
Médiafolyam ↔ Realtime API
A szervered továbbítja a hangot a Twilio Médiafolyam és az OpenAI Realtime API között.
Hangválasz → Felhasználó
A Realtime API-ból érkező válaszhangot a Twilio visszajuttatja a felhasználó telefonjára.
Megvalósítás Twilióval
Bejövő hívás webhook
Amikor hívás érkezik, a Twilio HTTP-kérést küld a szerverednek. Erre TwiML-lel válaszolsz, amely megnyitja a Médiafolyamot:
from fastapi import FastAPI, Request
from fastapi.responses import Response
app = FastAPI()
@app.post("/incoming-call")
async def incoming_call(request: Request):
"""Twilio webhook bejövő hívásokhoz."""
twiml = """<?xml version="1.0" encoding="UTF-8"?>
<Response>
<Say language="en-US">
Welcome to Corsen AI. Connecting you to your voice assistant.
</Say>
<Connect>
<Stream url="wss://your-server.com/media-stream">
<Parameter name="caller" value="{caller_number}" />
</Stream>
</Connect>
</Response>"""
form_data = await request.form()
caller = form_data.get("From", "unknown")
twiml = twiml.replace("{caller_number}", caller)
return Response(content=twiml, media_type="application/xml")
A Médiafolyam ↔ Realtime API híd
A WebSocket szerver fogadja a hangot a Twiliótól, és továbbítja a Realtime API felé:
from fastapi import WebSocket
import websockets
import json
import base64
import audioop
import asyncio
OPENAI_API_KEY = "sk-..."
REALTIME_URL = "wss://api.openai.com/v1/realtime?model=gpt-realtime-2.1"
@app.websocket("/media-stream")
async def media_stream(twilio_ws: WebSocket):
"""Híd a Twilio Médiafolyam és a Realtime API között."""
await twilio_ws.accept()
# Kapcsolódás a Realtime API-hoz
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(REALTIME_URL, additional_headers=headers) as openai_ws:
await openai_ws.recv() # session.created
# Munkamenet konfigurálása
await openai_ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"output_modalities": ["audio"],
"instructions": "You are a phone assistant. "
"Respond in English, concisely.",
"audio": {
"input": {
"format": {"type": "audio/pcmu"},
"turn_detection": {
"type": "server_vad",
"threshold": 0.5,
"silence_duration_ms": 600
}
},
"output": {
"format": {"type": "audio/pcmu"},
"voice": "marin"
}
}
}
}))
await openai_ws.recv()
stream_sid = None
async def twilio_to_openai():
nonlocal stream_sid
async for message in twilio_ws.iter_text():
data = json.loads(message)
if data["event"] == "media":
audio_b64 = data["media"]["payload"]
await openai_ws.send(json.dumps({
"type": "input_audio_buffer.append",
"audio": audio_b64
}))
elif data["event"] == "start":
stream_sid = data["start"]["streamSid"]
async def openai_to_twilio():
async for message in openai_ws:
event = json.loads(message)
if event["type"] == "response.output_audio.delta":
await twilio_ws.send_json({
"event": "media",
"streamSid": stream_sid,
"media": {
"payload": event["delta"]
}
})
await asyncio.gather(twilio_to_openai(), openai_to_twilio())
G.711 hangformátum
A telefónia a G.711 μ-law formátumot használja (8 kHz, mintánként egy bájt). A Realtime API ezt natívan támogatja audio/pcmu néven, amit mind a bemenet, mind a kimenet esetében megadhatsz (audio.input.format és audio.output.format, ahogy a fenti kódban is látható). Ez kiküszöböli a szerveroldali konverzió szükségességét. A g711_ulaw elnevezés az API béta verziójához tartozott; az A-law megfelelőjének neve audio/pcma.
Twilio alternatívák
| Platform | Erősség | Realtime API integráció |
|---|---|---|
| Twilio | Teljes ökoszisztéma, számok 100+ országban | Natív WebSocket Médiafolyamok |
| LiveKit | Nyílt forráskódú, alacsony késleltetés, WebRTC | Hivatalos OpenAI bővítmény |
| Daily | Egyszerű, hosztolt, prototípusozáshoz ideális | Pipecat SDK Realtime csatlakozóval |
Főbb megállapítások
- A Twilio Médiafolyamok lehetővé teszik, hogy egy telefonhívást kétirányú WebSockethez kapcsolj
- A szervered hídként működik a Twilio Médiafolyam és az OpenAI Realtime API között
- A G.711 μ-law formátum natív a telefóniában, és a Realtime API közvetlenül támogatja
- A LiveKit (nyílt forráskódú, WebRTC) és a Daily (hosztolt) életképes alternatívák a Twilio helyett
- Az architektúra mindig ugyanaz: telefónia → szervered → Realtime API