Rejestrowanie połączeń Twilio

Kiedy użyć każdego podejścia

Zanim zaczniesz, poznaj różnice między natywną integracją a metodą rejestrowania połączeń:

Omówienie

Endpoint rejestrowania połączeń pozwala używać własnej infrastruktury Twilio, jednocześnie korzystając z agentów ElevenLabs do prowadzenia rozmowy. Zamiast importować numer Twilio do ElevenLabs, zachowujesz pełną kontrolę nad konfiguracją Twilio i używasz API ElevenLabs do rejestrowania połączeń oraz odbierania TwiML, który łączy je z twoimi agentami.

To podejście jest idealne, gdy:

• Musisz zachować istniejącą infrastrukturę i workflow Twilio
• Chcesz programowo kontrolować routing i obsługę połączeń
• Masz złożone przepływy połączeń, które wymagają własnej logiki Twilio przed połączeniem z agentem
• Musisz zintegrować agentów ElevenLabs z istniejącym systemem telefonicznym

Jak to działa

1. Twój serwer odbiera połączenie przychodzące lub inicjuje połączenie wychodzące przez Twilio
2. Twój serwer wywołuje endpoint rejestrowania połączeń ElevenLabs z danymi agenta i połączenia
3. ElevenLabs zwraca TwiML, który łączy połączenie z agentem przez WebSocket
4. Zwracasz ten TwiML do Twilio, aby ustanowić połączenie

Wymagania wstępne

• Konto ElevenLabs
• Skonfigurowany Agent konwersacyjny ElevenLabs (utwórz go tutaj)
• Konto Twilio z aktywnym numerem telefonu
• Agent skonfigurowany z formatem audio μ-law 8000 Hz (zobacz konfigurację agenta)

Konfiguracja agenta

Przed użyciem endpointu rejestrowania połączeń skonfiguruj agenta tak, aby używał właściwego formatu audio obsługiwanego przez Twilio.

1

Skonfiguruj wyjście TTS

1. Przejdź do ustawień agenta
2. Przejdź do sekcji Voice
3. Z listy rozwijanej wybierz „μ-law 8000 Hz”

2

Ustaw format wejściowy

1. Przejdź do ustawień agenta
2. Przejdź do sekcji Advanced
3. Wybierz „μ-law 8000 Hz” jako format wejściowy

Dokumentacja API

Endpoint rejestrowania połączeń przyjmuje następujące parametry:

Endpoint zwraca TwiML, który należy przekazać bezpośrednio do Twilio.

Implementacja

import os
from fastapi import FastAPI, Request
from fastapi.responses import Response
from elevenlabs import ElevenLabs
app = FastAPI()
elevenlabs = ElevenLabs()
AGENT_ID = os.getenv("ELEVENLABS_AGENT_ID")
@app.post("/twilio/inbound")
async def handle_inbound_call(request: Request):
    form_data = await request.form()
    from_number = form_data.get("From")
    to_number = form_data.get("To")
    # Register the call with ElevenLabs
    twiml = elevenlabs.conversational_ai.twilio.register_call(
        agent_id=AGENT_ID,
        from_number=from_number,
        to_number=to_number,
        direction="inbound",
        conversation_initiation_client_data={
            "dynamic_variables": {
                "caller_number": from_number,
            }
        }
    )
    # Return the TwiML directly to Twilio
    return Response(content=twiml, media_type="application/xml")
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Połączenia wychodzące

W przypadku połączeń wychodzących zainicjuj połączenie przez Twilio i skieruj adres URL webhooka na swój serwer, który następnie rejestruje je w ElevenLabs:

from twilio.rest import Client
import os
from fastapi import Request
from fastapi.responses import Response
from elevenlabs import ElevenLabs
# Initialize clients
twilio_client = Client(
    os.getenv("TWILIO_ACCOUNT_SID"),
    os.getenv("TWILIO_AUTH_TOKEN")
)
elevenlabs = ElevenLabs()
AGENT_ID = os.getenv("ELEVENLABS_AGENT_ID")
def initiate_outbound_call(to_number: str):
    call = twilio_client.calls.create(
        from_=os.getenv("TWILIO_PHONE_NUMBER"),
        to=to_number,
        url="https://your-server.com/twilio/outbound"
    )
    return call.sid
@app.post("/twilio/outbound")
async def handle_outbound_webhook(request: Request):
    form_data = await request.form()
    from_number = form_data.get("From")
    to_number = form_data.get("To")
    twiml = elevenlabs.conversational_ai.twilio.register_call(
        agent_id=AGENT_ID,
        from_number=from_number,
        to_number=to_number,
        direction="outbound",
    )
    return Response(content=twiml, media_type="application/xml")

Personalizacja rozmów

Użyj parametru conversation_initiation_client_data, aby przekazać zmienne dynamiczne i nadpisać konfigurację agenta:

{
  "agent_id": "your-agent-id",
  "from_number": "+1234567890",
  "to_number": "+0987654321",
  "direction": "inbound",
  "conversation_initiation_client_data": {
    "dynamic_variables": {
      "customer_name": "John Doe",
      "account_type": "premium",
      "order_id": "ORD-12345"
    }
  }
}

Konfiguracja Twilio

Skonfiguruj numer telefonu Twilio, aby wskazywał na twój serwer:

1

Utwórz publiczny URL

W lokalnym środowisku deweloperskim użyj ngrok, aby udostępnić serwer:

ngrok http 8000

2

Skonfiguruj numer Twilio

1. Przejdź do konsoli Twilio
2. Przejdź do Phone Numbers > Manage > Active numbers
3. Wybierz swój numer telefonu
4. W sekcji „Voice Configuration” ustaw adres URL webhooka na endpoint serwera (np. https://your-ngrok-url.ngrok.app/twilio/inbound)
5. Ustaw metodę HTTP na POST

Ograniczenia

Podczas używania endpointu rejestrowania połączeń zamiast natywnej integracji:

• Brak przekazywania połączeń: Funkcja przekazywania nie jest dostępna, ponieważ ElevenLabs nie ma dostępu do twoich poświadczeń Twilio
• Ręczna konfiguracja: Musisz samodzielnie skonfigurować formaty audio i obsłużyć routing TwiML
• Brak importu w panelu: Numery telefonów zarejestrowane w ten sposób nie pojawiają się w panelu numerów telefonów ElevenLabs