Salt la conținutul principal
Română— Alege o limbă
Meniu

Integrarea telefonică (Twilio, etc.)

Lecția 15 din 18 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Integrarea telefonică (Twilio, etc.)
  2. Arhitectura telefonică
  3. Implementare cu Twilio
  4. Alternative la Twilio
  5. Puncte cheie

Actualizat la 3 noiembrie 2026 pe baza documentației Realtime API: formatul G.711 μ-law se numește audio/pcmu (textul anterior cita g711_ulaw, care era numele din perioada beta). Sursă: Realtime API.

Actualizare 2 noiembrie 2026 — Modele audio. Mai multe modele din acest curs sunt depreciate: tts-1, tts-1-hd și gpt-4o-mini-tts vor înceta să funcționeze la 6 ianuarie 2027 (înlocuitorul indicat este gpt-realtime-2.1-mini, pe care ghidul OpenAI TTS precizează că nu este suportat de /v1/audio/speech: migrarea sintezei vocale trebuie făcută prin Realtime API); gpt-realtime, gpt-4o-realtime și modelele audio legacy la 20 ianuarie 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe și /v1/audio/translations la 26 februarie 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pentru voce full-duplex, GPT-Live 1 este disponibil în API din 10 septembrie 2026.

Integrarea telefonică (Twilio, etc.)

Un agent vocal devine cu adevărat util atunci când este accesibil prin telefon. Platformele de telefonie cloud, precum Twilio, LiveKit și Daily, vă permit să conectați Realtime API la rețeaua telefonică globală. Un utilizator formează un număr, iar agentul dumneavoastră răspunde în timp real.

Arhitectura telefonică

Integrarea telefonică adaugă un strat intermediar între rețeaua telefonică și Realtime API:

1

Apel primit → Twilio

Utilizatorul formează un număr de telefon. Twilio primește apelul și trimite un webhook către serverul dumneavoastră.

2

Serverul dumneavoastră → Flux media

Serverul dumneavoastră răspunde cu instrucțiuni TwiML care deschid un WebSocket Media Stream bidirecțional.

3

Flux media ↔ Realtime API

Serverul dumneavoastră retransmite audio între Twilio Media Stream și OpenAI Realtime API.

4

Răspuns vocal → Utilizator

Audio-ul de răspuns de la Realtime API este trimis înapoi prin Twilio către telefonul utilizatorului.

Implementare cu Twilio

Webhook pentru apeluri primite

Când sosește un apel, Twilio trimite o cerere HTTP către serverul dumneavoastră. Răspundeți cu TwiML care deschide un Media Stream:

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

app = FastAPI()

@app.post("/incoming-call")
async def incoming_call(request: Request):
    """Webhook Twilio pentru apeluri primite."""
    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")

Podul Flux media ↔ Realtime API

Serverul WebSocket primește audio de la Twilio și îl retransmite către 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):
    """Pod între Twilio Media Stream și Realtime API."""
    await twilio_ws.accept()

    # Conectare la 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

        # Configurarea sesiunii
        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())

Formatul audio G.711

Telefonia utilizează formatul G.711 μ-law (8 kHz, un octet per eșantion). Realtime API suportă acest format nativ sub denumirea audio/pcmu, pe care îl declarați atât pentru intrare, cât și pentru ieșire (audio.input.format și audio.output.format, ca în codul de mai sus). Acest lucru evită orice conversie lato parte a serverului. Numele g711_ulaw aparținea versiunii beta a API-ului; echivalentul A-law se numește audio/pcma.

Alternative la Twilio

Platformă Punct forte Integrare Realtime API
Twilio Ecosistem complet, numere în peste 100 de țări Fluxuri media WebSocket native
LiveKit Open source, latență redusă, WebRTC Plugin oficial OpenAI
Daily Simplu, găzduit, ideal pentru prototipare SDK Pipecat cu conector Realtime

Puncte cheie

  • Twilio Media Streams vă permite să conectați un apel telefonic la un WebSocket bidirecțional
  • Serverul dumneavoastră acționează ca un pod între Twilio Media Stream și OpenAI Realtime API
  • Formatul G.711 μ-law este nativ în telefonie și suportat direct de Realtime API
  • LiveKit (open source, WebRTC) și Daily (găzduit) sunt alternative viabile la Twilio
  • Arhitectura este întotdeauna aceeași: telefonie → serverul dumneavoastră → Realtime API