Integrācija ar telefoniju (Twilio u.c.)
Šajā lapā
Atjaunināts 2026. gada 3. novembrī, pamatojoties uz Realtime API dokumentāciju: G.711 μ-law formāts tiek dēvēts par
audio/pcmu(iepriekš minētaisg711_ulawbija beta versijas nosaukums). Avots: Realtime API.
2026. gada 2. novembra atjauninājums — Audio modeļi. Vairāki šajā kursā aplūkotie modeļi tiek izslēgti no lietošanas:
tts-1,tts-1-hdungpt-4o-mini-ttspārtrauks darboties 2027. gada 6. janvārī (norādītā aizstājēja irgpt-realtime-2.1-mini, ko OpenAI TTS rokasgrāmata definē kā ** neatbalstītu ar/v1/audio/speech**: runas sintēzes migrācijai jānotiek caur 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 balss saziņai GPT-Live 1 ir pieejams API kopš 2026. gada 10. septembra.
Integrācija ar telefoniju (Twilio u.c.)
Balss aģents kļūst patiesi noderīgs, kad tas ir pieejams pa tālruni. Mākoņa telefonijas platformas, piemēram, Twilio, LiveKit un Daily, ļauj savienot Realtime API ar globālo tālruņu tīklu. Lietotājs izsauc numuru, un tavs aģents atbild reāllaikā.
Telefonijas arhitektūra
Integrācija ar telefoniju pievieno slāni starp tālruņu tīklu un Realtime API:
Ienākošais zvans → Twilio
Lietotājs izsauc tālruņa numuru. Twilio saņem zvanu un nosūta tīmekļa āķi (webhook) uz tavu serveri.
Tavs serveris → Mediju straume
Tavs serveris atbild ar TwiML instrukcijām, kas atver divvirzienu Media Stream WebSocket savienojumu.
Mediju straume ↔ Realtime API
Tavs serveris pārsūta audio datus starp Twilio Media Stream un OpenAI Realtime API.
Balss atbilde → Lietotājs
Atbildes audio no Realtime API tiek nosūtīts atpakaļ caur Twilio uz lietotāja tālruni.
Implementācija ar Twilio
Ienākošā zvana tīmekļa āķis (Webhook)
Kad ienāk zvans, Twilio nosūta HTTP pieprasījumu tavam serverim. Tu atbildi ar TwiML, kas atver mediju straumi:
from fastapi import FastAPI, Request
from fastapi.responses import Response
app = FastAPI()
@app.post("/incoming-call")
async def incoming_call(request: Request):
"""Twilio webhook for incoming calls."""
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")
Tilts starp mediju straumi un Realtime API
WebSocket serveris saņem audio no Twilio un pārsūta to uz Realtime API:
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):
"""Bridge between Twilio Media Stream and the Realtime API."""
await twilio_ws.accept()
# Connect to the Realtime API
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
# Configure the session
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 audio formāts
Telefonijā tiek izmantots G.711 μ-law formāts (8 kHz, viens baits paraugam). Realtime API to atbalsta dabiski ar nosaukumu audio/pcmu, kas jānorāda gan ievadei, gan izvadei (audio.input.format un audio.output.format, kā redzams iepriekšējā kodā). Tas novērš jebkādu konvertēšanu servera pusē. Nosaukums g711_ulaw piederēja API beta versijai; A-law ekvivalents tiek dēvēts par audio/pcma.
Twilio alternatīvas
| Platforma | Priekšrocība | Integrācija ar Realtime API |
|---|---|---|
| Twilio | Pilnīga ekosistēma, numuri 100+ valstīs | Dabiski WebSocket mediju straumējumi |
| LiveKit | Atvērtā koda, zema latentuma, WebRTC | Oficiālais OpenAI spraudnis |
| Daily | Vienkāršs, mitināts, piemērots prototipēšanai | Pipecat SDK ar Realtime konektoru |
Galvenās atziņas
- Twilio Media Streams ļauj savienot telefona zvanu ar divvirzienu WebSocket
- Tavs serveris darbojas kā tilts starp Twilio Media Stream un OpenAI Realtime API
- G.711 μ-law formāts ir dabisks telefonijai un tieši atbalstīts Realtime API
- LiveKit (atvērtā koda, WebRTC) un Daily (mitināts) ir dzīvotspējīgas Twilio alternatīvas
- Arhitektūra vienmēr ir vienāda: telefonija → tavs serveris → Realtime API