Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Telefónia integráció (Twilio és társai)

15. lecke 18 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Telefónia integráció (Twilio és társai)
  2. Telefónia architektúra
  3. Megvalósítás Twilióval
  4. Twilio alternatívák
  5. Főbb megállapítások

Frissítve: 2026. november 3. a Realtime API dokumentációja alapján: a G.711 μ-law formátum neve audio/pcmu (a korábbi szöveg a g711_ulaw nevet említette, ami a béta verzió elnevezése volt). Forrás: Realtime API.

2026. november 2-i frissítés — Hangmodellek. A tanfolyam számos modellje elavult: a tts-1, tts-1-hd és a gpt-4o-mini-tts modellek 2027. január 6-án megszűnnek működni (a javasolt utód a gpt-realtime-2.1-mini, amelyet az OpenAI TTS útmutatója szerint a /v1/audio/speech végpont nem támogat: a beszédszintézis migrációját kizárólag a Realtime API-n keresztül kell végrehajtani); a gpt-realtime, gpt-4o-realtime és a legacy hangmodellek 2027. január 20-án válnak elavulttá (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); a whisper-1, gpt-4o-transcribe és a /v1/audio/translations végpontok pedig 2027. február 26-án (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). A teljes duplex hangkommunikációhoz a GPT-Live 1 már 2026. szeptember 10. óta elérhető az API-ban.

Telefónia integráció (Twilio és társai)

Egy hangügynök akkor válik igazán hasznossá, ha telefonon is elérhető. A Twilio, a LiveKit és a Daily gibi felhőalapú telefónia-platformok lehetővé teszik, hogy a Realtime API-t összekapcsold a globális telefonhálózattal. A felhasználó felhív egy számot, az ügynököd pedig valós időben válaszol.

Telefónia architektúra

A telefónia integráció egy réteget illeszt a telefonhálózat és a Realtime API közé:

1

Bejövő hívás → Twilio

A felhasználó felhív egy telefonszámot. A Twilio fogadja a hívást, és webhookot küld a szerverednek.

2

Szervered → Médiafolyam

A szervered TwiML utasításokkal válaszol, amelyek megnyitnak egy kétirányú Médiafolyam WebSocket kapcsolatot.

3

Médiafolyam ↔ Realtime API

A szervered továbbítja a hangot a Twilio Médiafolyam és az OpenAI Realtime API között.

4

Hangválasz → Felhasználó

A Realtime API-ból érkező válaszhangot a Twilio visszajuttatja a felhasználó telefonjára.

Megvalósítás Twilióval

Bejövő hívás webhook

Amikor hívás érkezik, a Twilio HTTP-kérést küld a szerverednek. Erre TwiML-lel válaszolsz, amely megnyitja a Médiafolyamot:

from fastapi import FastAPI, Request
from fastapi.responses import Response

app = FastAPI()

@app.post("/incoming-call")
async def incoming_call(request: Request):
    """Twilio webhook bejövő hívásokhoz."""
    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")

A Médiafolyam ↔ Realtime API híd

A WebSocket szerver fogadja a hangot a Twiliótól, és továbbítja a Realtime API felé:

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):
    """Híd a Twilio Médiafolyam és a Realtime API között."""
    await twilio_ws.accept()

    # Kapcsolódás a Realtime API-hoz
    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

        # Munkamenet konfigurálása
        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 hangformátum

A telefónia a G.711 μ-law formátumot használja (8 kHz, mintánként egy bájt). A Realtime API ezt natívan támogatja audio/pcmu néven, amit mind a bemenet, mind a kimenet esetében megadhatsz (audio.input.format és audio.output.format, ahogy a fenti kódban is látható). Ez kiküszöböli a szerveroldali konverzió szükségességét. A g711_ulaw elnevezés az API béta verziójához tartozott; az A-law megfelelőjének neve audio/pcma.

Twilio alternatívák

Platform Erősség Realtime API integráció
Twilio Teljes ökoszisztéma, számok 100+ országban Natív WebSocket Médiafolyamok
LiveKit Nyílt forráskódú, alacsony késleltetés, WebRTC Hivatalos OpenAI bővítmény
Daily Egyszerű, hosztolt, prototípusozáshoz ideális Pipecat SDK Realtime csatlakozóval

Főbb megállapítások

  • A Twilio Médiafolyamok lehetővé teszik, hogy egy telefonhívást kétirányú WebSockethez kapcsolj
  • A szervered hídként működik a Twilio Médiafolyam és az OpenAI Realtime API között
  • A G.711 μ-law formátum natív a telefóniában, és a Realtime API közvetlenül támogatja
  • A LiveKit (nyílt forráskódú, WebRTC) és a Daily (hosztolt) életképes alternatívák a Twilio helyett
  • Az architektúra mindig ugyanaz: telefónia → szervered → Realtime API