Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Telefoni-integration (Twilio osv.)

Lektion 15 af 18 Opdateret 3. november 2026 Udvikler
På denne side
  1. Telefoni-integration (Twilio osv.)
  2. Telefoni-arkitektur
  3. Implementering med Twilio
  4. Alternativer til Twilio
  5. Vigtige pointer

Opdateret 3. november 2026 baseret på dokumentationen for Realtime API: G.711 μ-law-formatet hedder nu audio/pcmu (teksten citerede tidligere g711_ulaw, hvilket var beta-navnet). Kilde: Realtime API.

Opdatering 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset: tts-1, tts-1-hd og gpt-4o-mini-tts ophører med at fungere den 6. januar 2027 (den angivne erstatning er gpt-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-realtime og ældre lydmodeller udfases den 20. januar 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe og /v1/audio/translations udfases 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:

1

Indgående opkald → Twilio

Brugeren ringer til et telefonnummer. Twilio modtager opkaldet og sender en webhook til din server.

2

Din server → Media Stream

Din server svarer med TwiML-instruktioner, der åbner en bidirektionel Media Stream WebSocket.

3

Media Stream ↔ Realtime API

Din server videresender lyd mellem Twilio Media Stream og OpenAI Realtime API.

4

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