Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Telefonisüsteemide integreerimine (Twilio jne)

Õppetund 15 / 18 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Telefonisüsteemide integreerimine (Twilio jne)
  2. Telefonisüsteemi arhitektuur
  3. Teostus Twilio abil
  4. Twilio alternatiivid
  5. Peamised punktid

Uuendatud 3. novembril 2026 vastavalt Realtime API dokumentatsioonile: G.711 μ-law formaadi nimi on audio/pcmu (varasemas tekstis viidati nimele g711_ulaw, mis oli beetaversiooni nimi). Allikas: Realtime API.

2. novembri 2026 uuendus — Audiomudelid. Selles kursuses on mitu mudelit aegunud: tts-1, tts-1-hd ja gpt-4o-mini-tts lõpetavad töö 6. jaanuaril 2027 (asendajaks on märgitud gpt-realtime-2.1-mini, mille OpenAI TTS juhend nimetab mittetoetuks /v1/audio/speech poolt: kõnesünteesi migratsioon peab toimuma läbi Realtime API); gpt-realtime, gpt-4o-realtime ja vanad audiomudelid 20. jaanuaril 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe ja /v1/audio/translations 26. veebruaril 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Täisdupleksseks hääleks on GPT-Live 1 olnud API-s saadaval alates 10. septembrist 2026.

Telefonisüsteemide integreerimine (Twilio jne)

Hääleagent muutub tõeliselt kasulikuks siis, kui see on telefoni teel kättesaadav. Pilvepõhised telefoniplatvormid nagu Twilio, LiveKit ja Daily võimaldavad sul ühendada Realtime API globaalse telefonivõrguga. Kasutaja helistab numbrile ja sinu agent vastab reaalajas.

Telefonisüsteemi arhitektuur

Telefonisüsteemi integreerimine lisab kihi telefonivõrgu ja Realtime API vahele:

1

Sissetulev kõne → Twilio

Kasutaja helistab telefoninumbrile. Twilio võtab kõne vastu ja saadab sinu serverile veebikonksu (webhook).

2

Sinu server → Meediavoog

Sinu server vastab TwiML-i juhistega, mis avavad kahepoolse meediavoo WebSocket-i ühenduse.

3

Meediavoog ↔ Realtime API

Sinu server edastab heli Twilio meediavoo ja OpenAI Realtime API vahel.

4

Häälvastus → Kasutaja

Realtime API-st tulev vastusheli saadetakse Twilio kaudu tagasi kasutaja telefonile.

Teostus Twilio abil

Sissetuleva kõne veebikonks

Kui kõne saabub, saadab Twilio sinu serverile HTTP-päringu. Sa vastad TwiML-iga, mis avab meediavoo:

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

app = FastAPI()

@app.post("/incoming-call")
async def incoming_call(request: Request):
    """Twilio veebikonks sissetulevate kõnede jaoks."""
    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")

Meediavoo ja Realtime API sild

WebSocketi server võtab Twiliolt heli vastu ja edastab selle Realtime API-le:

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):
    """Sild Twilio meediavoo ja Realtime API vahel."""
    await twilio_ws.accept()

    # Ühendu Realtime API-ga
    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

        # Seadista seanss
        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 heliformaat

Telefonisüsteemid kasutavad G.711 μ-law formaati (8 kHz, üks bait proovi kohta). Realtime API toetab seda loomupäraselt nime audio/pcmu all, mille deklareerid nii sisendi kui väljundi jaoks (audio.input.format ja audio.output.format, nagu ülalolevas koodis). See välistab igasuguse serveripoolse teisenduse. Nimi g711_ulaw kuulus API beetaversioonile; A-law ekvivalent kannab nime audio/pcma.

Twilio alternatiivid

Platvorm Tugevus Realtime API integreerimine
Twilio Terviklik ökosüsteem, numbrid enam kui 100 riigis Loomulikud WebSocketi meediavood
LiveKit Avatud lähtekood, väike viivitus, WebRTC Ametlik OpenAI pistikprogramm
Daily Lihtne, majutatud, hea prototüüpimiseks Pipecat SDK koos Realtime ühendusega

Peamised punktid

  • Twilio Media Streams võimaldab ühendada telefonikõne kahepoolse WebSocketiga
  • Sinu server toimib sillana Twilio meediavoo ja OpenAI Realtime API vahel
  • G.711 μ-law formaat on telefonisüsteemidele omane ja Realtime API toetab seda otseselt
  • LiveKit (avatud lähtekood, WebRTC) ja Daily (majutatud) on Twiliole elujõulised alternatiivid
  • Arhitektuur on alati sama: telefonivõrk → sinu server → Realtime API