Integrarea telefonică (Twilio, etc.)
Pe această pagină
Actualizat la 3 noiembrie 2026 pe baza documentației Realtime API: formatul G.711 μ-law se numește
audio/pcmu(textul anterior citag711_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șigpt-4o-mini-ttsvor înceta să funcționeze la 6 ianuarie 2027 (înlocuitorul indicat estegpt-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/translationsla 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:
Apel primit → Twilio
Utilizatorul formează un număr de telefon. Twilio primește apelul și trimite un webhook către serverul dumneavoastră.
Serverul dumneavoastră → Flux media
Serverul dumneavoastră răspunde cu instrucțiuni TwiML care deschid un WebSocket Media Stream bidirecțional.
Flux media ↔ Realtime API
Serverul dumneavoastră retransmite audio între Twilio Media Stream și OpenAI Realtime API.
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