Build a Smart AI Call Router: Let Intent Decide Where Every Call Goes

Incoming Call
     ↓
VoIPBin answers → speaks greeting → STT captures response
     ↓
Webhook → Your Server
     ↓
LLM classifies intent ("billing", "support", "sales", "other")
     ↓
VoIPBin executes route-specific flow (transfer / speak / hang up)

curl -s -X POST https://api.voipbin.net/v1.0/auth/signup \
  -H "Content-Type: application/json" \
  -d '{"username": "your@email.com", "password": "yourpassword"}'

curl -s -X POST https://api.voipbin.net/v1.0/numbers \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "country_code": "US",
    "number_type": "local",
    "webhook_url": "https://your-server.com/call/incoming"
  }'

from openai import OpenAI

client = OpenAI(api_key="YOUR_OPENAI_KEY")

ROUTES = {
    "billing": "Caller asking about invoices, payments, refunds, or charges",
    "support": "Caller reporting a bug, outage, or needing technical help",
    "sales":   "Caller asking about pricing, plans, demos, or purchasing",
    "other":   "Anything that doesn't match the above"
}

def classify_intent(transcript: str) -> str:
    route_desc = "\n".join(f"- {k}: {v}" for k, v in ROUTES.items())
    prompt = f"""Classify the caller's intent into exactly one of: billing, support, sales, other.

Routes:\n{route_desc}

Caller said: \"{transcript}\"

Respond with only the route name."""

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=10,
        temperature=0
    )
    return response.choices[0].message.content.strip().lower()

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

VOIPBIN_TOKEN = "YOUR_TOKEN"
VOIPBIN_BASE  = "https://api.voipbin.net/v1.0"

# Map intent → human agent SIP URIs or VoIPBin flow IDs
ROUTE_MAP = {
    "billing": {"type": "transfer", "destination": "sip:billing@yourdomain.com"},
    "support": {"type": "transfer", "destination": "sip:support@yourdomain.com"},
    "sales":   {"type": "transfer", "destination": "sip:sales@yourdomain.com"},
    "other":   {"type": "speak",    "text": "I'm not sure how to help with that. Let me connect you to our main team."},
}

@app.route("/call/incoming", methods=["POST"])
def handle_call():
    body = request.json
    call_id = body["call_id"]

    # Step 1: Greet the caller and collect their voice input
    _send_action(call_id, {
        "action": "speak_and_listen",
        "text": "Hi, thanks for calling. How can I help you today?",
        "listen_webhook": "https://your-server.com/call/response"
    })
    return jsonify({"status": "ok"})

@app.route("/call/response", methods=["POST"])
def handle_response():
    body = request.json
    call_id    = body["call_id"]
    transcript = body.get("transcript", "")

    intent = classify_intent(transcript)
    route  = ROUTE_MAP.get(intent, ROUTE_MAP["other"])

    if route["type"] == "transfer":
        _send_action(call_id, {
            "action": "speak",
            "text": f"Let me connect you to our {intent} team."
        })
        _send_action(call_id, {
            "action": "transfer",
            "destination": route["destination"]
        })
    else:
        _send_action(call_id, {
            "action": "speak",
            "text": route["text"]
        })

    return jsonify({"status": "ok"})

def _send_action(call_id: str, payload: dict):
    requests.post(
        f"{VOIPBIN_BASE}/calls/{call_id}/actions",
        headers={"Authorization": f"Bearer {VOIPBIN_TOKEN}"},
        json=payload
    )

if __name__ == "__main__":
    app.run(port=5000)

def classify_intent_with_confidence(transcript: str) -> tuple[str, float]:
    prompt = f"""Classify intent as billing/support/sales/other.
Also give a confidence score 0.0-1.0.
Format: intent|score

Caller: \"{transcript}\""""

    result = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=20,
        temperature=0
    ).choices[0].message.content.strip()

    parts = result.split("|")
    intent = parts[0].strip()
    score  = float(parts[1].strip()) if len(parts) > 1 else 0.5
    return intent, score

# In your webhook handler:
intent, confidence = classify_intent_with_confidence(transcript)

if confidence < 0.7:
    # Ask a clarifying question
    _send_action(call_id, {
        "action": "speak_and_listen",
        "text": "Could you tell me a bit more — are you calling about a technical issue, billing, or something else?",
        "listen_webhook": "https://your-server.com/call/response"
    })
else:
    # Route with confidence
    ...

ROUTES["appointment"] = "Caller wants to schedule or reschedule a meeting"
ROUTE_MAP["appointment"] = {
    "type": "flow",
    "flow_id": "your-voipbin-booking-flow-id"
}