Telefoni-integration (Twilio osv.)
På denne side
Opdateret 3. november 2026 baseret på dokumentationen for Realtime API: G.711 μ-law-formatet hedder nu
audio/pcmu(teksten citerede tidligereg711_ulaw, hvilket var beta-navnet). Kilde: Realtime API.
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 (den angivne erstatning ergpt-realtime-2.1-mini, som OpenAI’s TTS-guide angiver ikke understøttes af/v1/audio/speech: migration af talesyntese skal ske via Realtime API);gpt-realtime,gpt-4o-realtimeog ældre lydmodeller udfases den 20. januar 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeog/v1/audio/translationsudfases den 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.
Telefoni-integration (Twilio osv.)
En taleagent bliver først rigtig nyttig, når den er tilgængelig via telefon. Cloud-telefoniplatforme som Twilio, LiveKit og Daily giver dig mulighed for at forbinde Realtime API til det globale telefonnetværk. En bruger ringer til et nummer, og din agent svarer i realtid.
Telefoni-arkitektur
Telefoni-integration tilføjer et lag mellem telefonnetværket og Realtime API:
Indgående opkald → Twilio
Brugeren ringer til et telefonnummer. Twilio modtager opkaldet og sender en webhook til din server.
Din server → Media Stream
Din server svarer med TwiML-instruktioner, der åbner en bidirektionel Media Stream WebSocket.
Media Stream ↔ Realtime API
Din server videresender lyd mellem Twilio Media Stream og OpenAI Realtime API.
Talesvar → Bruger
Svarlyden fra Realtime API sendes tilbage via Twilio til brugerens telefon.
Implementering med Twilio
Webhook for indgående opkald
Når et opkald ankommer, sender Twilio en HTTP-anmodning til din server. Du svarer med TwiML, der åbner 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 for indgående opkald."""
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")
Broen mellem Media Stream og Realtime API
WebSocket-serveren modtager lyd fra Twilio og videresender den til 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 mellem Twilio Media Stream og Realtime API."""
await twilio_ws.accept()
# Opret forbindelse til 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
# Konfigurer 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())
G.711-lydformat
Telefoni bruger G.711 μ-law-formatet (8 kHz, én byte pr. prøve). Realtime API understøtter dette nativt under navnet audio/pcmu, som du angiver for både input og output (audio.input.format og audio.output.format, som i koden ovenfor). Dette undgår enhver konvertering på serveren. Navnet g711_ulaw hørte til API-betaen; A-law-ækvivalenten hedder audio/pcma.
Alternativer til Twilio
| Platform | Styrke | Integration med Realtime API |
|---|---|---|
| Twilio | Komplet økosystem, numre i over 100 lande | Native WebSocket Media Streams |
| LiveKit | Open source, lav latency, WebRTC | Officielt OpenAI-plugin |
| Daily | Enkelt, hostet, godt til prototyping | Pipecat SDK med Realtime-stik |
Vigtige pointer
- Twilio Media Streams giver dig mulighed for at forbinde et telefonopkald til en bidirektionel WebSocket
- Din server fungerer som en bro mellem Twilio Media Stream og OpenAI Realtime API
- G.711 μ-law-formatet er indbygget i telefoni og understøttes direkte af Realtime API
- LiveKit (open source, WebRTC) og Daily (hostet) er levedygtige alternativer til Twilio
- Arkitekturen er altid den samme: telefoni → din server → Realtime API