Telefoniintegration (Twilio m.fl.)
På denna sida
Uppdaterat den 3 november 2026 baserat på dokumentationen för Realtime API: G.711 μ-law-formatet heter
audio/pcmu(texten citerade tidigareg711_ulaw, vilket var betanamnet). Källa: Realtime API.
Uppdatering 2 november 2026 — Ljudmodeller. Flera modeller i denna kurs är avvecklade:
tts-1,tts-1-hdochgpt-4o-mini-ttsslutar fungera den 6 januari 2027 (den angivna ersättaren ärgpt-realtime-2.1-mini, vilket OpenAI:s TTS-guide anger inte stöds av/v1/audio/speech: migrering av talgenerering måste ske via Realtime API);gpt-realtime,gpt-4o-realtimeoch äldre ljudmodeller den 20 januari 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeoch/v1/audio/translationsden 26 februari 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). För full duplex-röst har GPT-Live 1 funnits tillgänglig i API:t sedan den 10 september 2026.
Telefoniintegration (Twilio m.fl.)
En röstagent blir verkligen användbar när den går att nå via telefon. Molnbaserade telefoniplattformar som Twilio, LiveKit och Daily låter dig koppla Realtime API till det globala telefonnätet. En användare ringer ett nummer och din agent svarar i realtid.
Arkitektur för telefoni
Telefoniintegration lägger till ett lager mellan telefonnätet och Realtime API:
Inkommande samtal → Twilio
Användaren ringer ett telefonnummer. Twilio tar emot samtalet och skickar en webhook till din server.
Din server → Media Stream
Din server svarar med TwiML-instruktioner som öppnar en dubbelriktad WebSocket för Media Stream.
Media Stream ↔ Realtime API
Din server vidarebefordrar ljud mellan Twilio Media Stream och OpenAI Realtime API.
Röstsvar → Användare
Svarsljudet från Realtime API skickas tillbaka via Twilio till användarens telefon.
Implementering med Twilio
Webhook för inkommande samtal
När ett samtal kommer in skickar Twilio en HTTP-förfrågan till din server. Du svarar med TwiML som öppnar en Media Stream:
from fastapi import FastAPI, Request
from fastapi.responses import Response
app = FastAPI()
@app.post("/incoming-call")
async def incoming_call(request: Request):
"""Twilio-webhook för inkommande samtal."""
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")
Bron mellan Media Stream och Realtime API
WebSocket-servern tar emot ljud från Twilio och vidarebefordrar det till 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):
"""Bro mellan Twilio Media Stream och Realtime API."""
await twilio_ws.accept()
# Anslut till 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
# Konfigurera sessionen
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())
Ljudformatet G.711
Telefoni använder G.711 μ-law-formatet (8 kHz, en byte per sample). Realtime API stöder detta internt under namnet audio/pcmu, vilket du deklarerar för både in- och utmatning (audio.input.format och audio.output.format, som i koden ovan). Detta undviker all konvertering på serversidan. Namnet g711_ulaw tillhörde API:ets betafas; A-law-ekvivalenten heter audio/pcma.
Alternativ till Twilio
| Plattform | Styrka | Integration med Realtime API |
|---|---|---|
| Twilio | Komplett ekosystem, nummer i över 100 länder | Inbyggda WebSocket Media Streams |
| LiveKit | Öppen källkod, låg latens, WebRTC | Officiellt OpenAI-plugin |
| Daily | Enkelt, hostat, bra för prototyper | Pipecat SDK med Realtime-kontakt |
Viktiga punkter
- Twilio Media Streams låter dig koppla ett telefonsamtal till en dubbelriktad WebSocket
- Din server agerar som en bro mellan Twilio Media Stream och OpenAI Realtime API
- G.711 μ-law-formatet är inbyggt i telefoni och stöds direkt av Realtime API
- LiveKit (öppen källkod, WebRTC) och Daily (hostat) är gångbara alternativ till Twilio
- Arkitekturen är alltid densamma: telefoni → din server → Realtime API