Telefonisüsteemide integreerimine (Twilio jne)
Sellel lehel
Uuendatud 3. novembril 2026 vastavalt Realtime API dokumentatsioonile: G.711 μ-law formaadi nimi on
audio/pcmu(varasemas tekstis viidati nimeleg711_ulaw, mis oli beetaversiooni nimi). Allikas: Realtime API.
2. novembri 2026 uuendus — Audiomudelid. Selles kursuses on mitu mudelit aegunud:
tts-1,tts-1-hdjagpt-4o-mini-ttslõpetavad töö 6. jaanuaril 2027 (asendajaks on märgitudgpt-realtime-2.1-mini, mille OpenAI TTS juhend nimetab mittetoetuks/v1/audio/speechpoolt: kõnesünteesi migratsioon peab toimuma läbi Realtime API);gpt-realtime,gpt-4o-realtimeja vanad audiomudelid 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äisdupleksseks hääleks on GPT-Live 1 olnud API-s saadaval alates 10. septembrist 2026.
Telefonisüsteemide integreerimine (Twilio jne)
Hääleagent muutub tõeliselt kasulikuks siis, kui see on telefoni teel kättesaadav. Pilvepõhised telefoniplatvormid nagu Twilio, LiveKit ja Daily võimaldavad sul ühendada Realtime API globaalse telefonivõrguga. Kasutaja helistab numbrile ja sinu agent vastab reaalajas.
Telefonisüsteemi arhitektuur
Telefonisüsteemi integreerimine lisab kihi telefonivõrgu ja Realtime API vahele:
Sissetulev kõne → Twilio
Kasutaja helistab telefoninumbrile. Twilio võtab kõne vastu ja saadab sinu serverile veebikonksu (webhook).
Sinu server → Meediavoog
Sinu server vastab TwiML-i juhistega, mis avavad kahepoolse meediavoo WebSocket-i ühenduse.
Meediavoog ↔ Realtime API
Sinu server edastab heli Twilio meediavoo ja OpenAI Realtime API vahel.
Häälvastus → Kasutaja
Realtime API-st tulev vastusheli saadetakse Twilio kaudu tagasi kasutaja telefonile.
Teostus Twilio abil
Sissetuleva kõne veebikonks
Kui kõne saabub, saadab Twilio sinu serverile HTTP-päringu. Sa vastad TwiML-iga, mis avab meediavoo:
from fastapi import FastAPI, Request
from fastapi.responses import Response
app = FastAPI()
@app.post("/incoming-call")
async def incoming_call(request: Request):
"""Twilio veebikonks sissetulevate kõnede jaoks."""
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")
Meediavoo ja Realtime API sild
WebSocketi server võtab Twiliolt heli vastu ja edastab selle Realtime API-le:
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):
"""Sild Twilio meediavoo ja Realtime API vahel."""
await twilio_ws.accept()
# Ühendu Realtime API-ga
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
# Seadista seanss
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 heliformaat
Telefonisüsteemid kasutavad G.711 μ-law formaati (8 kHz, üks bait proovi kohta). Realtime API toetab seda loomupäraselt nime audio/pcmu all, mille deklareerid nii sisendi kui väljundi jaoks (audio.input.format ja audio.output.format, nagu ülalolevas koodis). See välistab igasuguse serveripoolse teisenduse. Nimi g711_ulaw kuulus API beetaversioonile; A-law ekvivalent kannab nime audio/pcma.
Twilio alternatiivid
| Platvorm | Tugevus | Realtime API integreerimine |
|---|---|---|
| Twilio | Terviklik ökosüsteem, numbrid enam kui 100 riigis | Loomulikud WebSocketi meediavood |
| LiveKit | Avatud lähtekood, väike viivitus, WebRTC | Ametlik OpenAI pistikprogramm |
| Daily | Lihtne, majutatud, hea prototüüpimiseks | Pipecat SDK koos Realtime ühendusega |
Peamised punktid
- Twilio Media Streams võimaldab ühendada telefonikõne kahepoolse WebSocketiga
- Sinu server toimib sillana Twilio meediavoo ja OpenAI Realtime API vahel
- G.711 μ-law formaat on telefonisüsteemidele omane ja Realtime API toetab seda otseselt
- LiveKit (avatud lähtekood, WebRTC) ja Daily (majutatud) on Twiliole elujõulised alternatiivid
- Arhitektuur on alati sama: telefonivõrk → sinu server → Realtime API