Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Telefoniintegration (Twilio m.fl.)

Lektion 15 av 18 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Telefoniintegration (Twilio m.fl.)
  2. Arkitektur för telefoni
  3. Implementering med Twilio
  4. Alternativ till Twilio
  5. Viktiga punkter

Uppdaterat den 3 november 2026 baserat på dokumentationen för Realtime API: G.711 μ-law-formatet heter audio/pcmu (texten citerade tidigare g711_ulaw, vilket var betanamnet). Källa: Realtime API.

Uppdatering 2 november 2026 — Ljudmodeller. Flera modeller i denna kurs är avvecklade: tts-1, tts-1-hd och gpt-4o-mini-tts slutar fungera den 6 januari 2027 (den angivna ersättaren är gpt-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-realtime och äldre ljudmodeller den 20 januari 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe och /v1/audio/translations den 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:

1

Inkommande samtal → Twilio

Användaren ringer ett telefonnummer. Twilio tar emot samtalet och skickar en webhook till din server.

2

Din server → Media Stream

Din server svarar med TwiML-instruktioner som öppnar en dubbelriktad WebSocket för Media Stream.

3

Media Stream ↔ Realtime API

Din server vidarebefordrar ljud mellan Twilio Media Stream och OpenAI Realtime API.

4

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