DEV Community: BLACKDWARF

How We Built a Telephony AI Framework That Eliminates 90% of Voice Infrastructure Complexity

BLACKDWARF — Wed, 01 Apr 2026 12:21:07 +0000

Most developers underestimate how hard voice AI actually is.

To build a production-ready calling agent, you need to integrate:

– SIP signalling

– Real-time audio streaming

– Speech-to-text

– LLM orchestration

– Text-to-speech

Each layer introduces latency, failure points, and vendor dependencies.

That’s where Siphon comes in.

What Siphon Does

Siphon acts as a middleware layer between telephony systems and AI models, abstracting the entire pipeline into Python.

You define:

agent=Agent(...)

And Siphon handles:

– WebRTC streaming

– SIP negotiation

– Interrupt handling

– Model orchestration

Key Features

1. Sub-500ms latency

Human-like conversations require near-instant responses — Siphon achieves this using WebRTC streaming.

2. Modular AI stack

Swap LLMs, STT, and TTS providers with a single config change.

3. Zero-config scaling

Spin up more workers → Siphon auto-load-balances calls across nodes.

4. Data sovereignty

All data stays in your infrastructure — no third-party data leakage.

Why It Matters

Instead of spending months on infra, you can focus on:

– Agent logic

– Business workflows

– User experience

👉 Siphon turns voice AI into a developer problem, not an infrastructure nightmare.

Resources

Code & Documentation:

Found this helpful? ⭐ Star us on GitHub

Leave questions in the comment section! We would love to help you out.

opensource #python #ai #webRTC #voiceai #devtools

Build a 24/7 AI Receptionist in 15 Mins (Python + Google Calendar)

BLACKDWARF — Sun, 01 Feb 2026 12:16:17 +0000

Voice AI demos are cool, but they usually fail at one thing: doing actual work. Today, I'm sharing how to build a production-ready Dental Clinic Receptionist that actually checks a real Google Calendar and books appointments over the phone. We'll use Siphon (an open-source framework) to do it in few lines of logic.

This tutorial shows you how to create an intelligent voice agent that:

Books new appointments with calendar integration
Modifies and cancels existing appointments
Verifies caller identity for privacy
Operates 24/7 without human intervention

Time to build: ~15 minutes

Architecture Flow:

Prerequisites

Before starting, ensure you have:

Python 3.8+ installed on your system
SIPHON installed: pip install siphon-ai (Installation Guide)
API Keys:
- OpenRouter API key (Get one here)
- Sarvam or Cartesia API key for voice (TTS Plugins)
Services:
- LiveKit credentials (cloud/self-hosted)
- Google Calendar with service account credentials (Setup Guide) - Required for the agent to check availability on your behalf.

Documentation:

LLM Plugins - Configure language models
TTS Plugins - Text-to-speech providers
STT Plugins - Speech-to-text providers
Agent Configuration - Advanced settings
Call Data & Observability - Recordings, transcripts, and metadata

Quick Start

Step 1: Create Project

mkdir dental-clinic-receptionist
cd dental-clinic-receptionist
touch .env prompt.py agent.py inbound.py outbound.py

Step 2: Configure Environment

Edit .env:

# LLM Provider
OPENROUTER_API_KEY=your_key

# Voice Providers  
SARVAM_API_KEY=your_key
CARTESIA_API_KEY=your_key

# LiveKit Server
LIVEKIT_URL=wss://your-livekit-url
LIVEKIT_API_KEY=your_key
LIVEKIT_API_SECRET=your_secret

# Google Calendar
GOOGLE_CALENDAR_ID=your-calendar@gmail.com
GOOGLE_CALENDAR_CREDENTIALS_PATH=/path/to/credentials.json

# Call Data Features
# These flags enable automatic capturing of call artifacts
CALL_RECORDING=false           # Set to true to enable recordings (requires S3 config below)
SAVE_METADATA=true             # Saves call details (duration, status, cost)
SAVE_TRANSCRIPTION=true        # Saves full conversation history

# Storage Configuration
# Metadata and transcriptions are saved locally by default. 
# To save to S3, set METADATA_LOCATION=s3 and TRANSCRIPTION_LOCATION=s3
METADATA_LOCATION=Call_Metadata
TRANSCRIPTION_LOCATION=Transcriptions

# S3 Configuration (Required for Recordings, optional for Metadata/Transcriptions)
# AWS_S3_ENDPOINT=http://localhost:9000
# AWS_S3_ACCESS_KEY_ID=minioadmin
# AWS_S3_SECRET_ACCESS_KEY=minioadmin
# AWS_S3_BUCKET=siphon
# AWS_S3_REGION=us-east-1
# AWS_S3_FORCE_PATH_STYLE=true

Step 3: Create System Prompt

The system prompt defines your receptionist's behavior and conversation workflows.

Create prompt.py with your instructions. For a complete reference, see the example prompt on GitHub.

Basic structure:

system_instructions = """
You are a professional dental clinic receptionist.

# CAPABILITIES
- Book new appointments
- Modify existing appointments
- Cancel appointments

# PRIVACY RULES
- ALWAYS verify caller identity (name + phone) before showing appointments
- Only display appointments for the verified caller

# CONVERSATION STYLE
- Be warm and professional
- Ask one question at a time
- Confirm information by reading it back
"""

Step 4: Create the Agent

Create agent.py:

from siphon.agent import Agent
from siphon.plugins import openrouter, sarvam, cartesia
from prompt import system_instructions
from dotenv import load_dotenv

load_dotenv()

llm = openrouter.LLM()
tts = cartesia.TTS()
stt = sarvam.STT()

agent = Agent(
    agent_name="Dental-Clinic-Receptionist",
    llm=llm,
    tts=tts,
    stt=stt,
    system_instructions=system_instructions,
    google_calendar=True
)

if __name__ == "__main__":
    # One-time setup: downloads required VAD models and assets (only needed on fresh machines)
    # agent.download_files()

    # For local development (logs, quick iteration)
    agent.dev()

    # For production workers, use:
    # agent.start()

Agent Overview

Step 5: Set Up Inbound Calls

Create inbound.py:

from siphon.telephony.inbound import Dispatch
from dotenv import load_dotenv

load_dotenv()

dispatch = Dispatch(
    agent_name="Dental-Clinic-Receptionist",  # must match the agent_name used when defining/starting your agent worker
    dispatch_name="inbound-Dental-Clinic-Receptionist",
    sip_number=""  # from your SIP Provider
)

result = dispatch.agent()
print(result)

Run: python inbound.py

Inbound Calling Guide

Step 6: Set Up Outbound Calls (Optional)

Create outbound.py for appointment reminders:

from siphon.telephony import Call
from dotenv import load_dotenv

load_dotenv()

call = Call(
    agent_name="Dental-Clinic-Receptionist",  # must match the agent_name used when defining/starting your agent worker
    sip_trunk_setup={
        "name": "Dental-Clinic-Receptionist",
        "sip_address": "",
        "sip_number": "",
        "sip_username": "",
        "sip_password": ""
    },
    number_to_call=""
)

result = call.start()
print(result)

Run: python outbound.py

Outbound Calling Guide

Step 7: Start Your Agent

python agent.py

Your receptionist is now live and ready to handle calls.

Production Scaling:
For high-volume production deployments, you can run multiple instances of your agent script horizontally. It automatically distributes calls across available workers.
Learn more about Horizontal Scaling

Result

Now your AI receptionist can handle:

New Appointment Booking:

Patient calls: "I need a cleaning for next Tuesday at 2 PM"
Agent asks for name and phone number
Agent verifies details by reading them back
Agent checks calendar availability
Agent books appointment and confirms

Appointment Modifications:

Patient calls: "I need to change my appointment"
Agent verifies caller identity
Agent shows only their appointments
Agent reschedules to new time
Agent confirms changes

Appointment Cancellations:

Patient calls: "I want to cancel my appointment"
Agent verifies identity
Agent confirms which appointment to cancel
Agent cancels and confirms completion

Privacy Protection:

Built-in caller verification (name + phone)
Only shows appointments for verified caller
No cross-patient data exposure

Resources

Code & Documentation:

Found this helpful? ⭐ Star us on GitHub

SIPHON: The Telephony-First Framework for Calling AI

BLACKDWARF — Wed, 28 Jan 2026 17:09:47 +0000

Building an AI that can chat via text is now a solved problem. Building an AI that can handle a real phone call in production is still a nightmare of fragmented infrastructure.

Developers typically face a "plumbing" crisis: they must manually stitch together SIP trunks, manage real-time media buffers, handle signal interruptions, and wire up multiple AI providers—all while trying to keep latency low enough for a human conversation.

SIPHON was built to end the plumbing. It is an open-source Python framework that provides a unified, telephony-first abstraction for building and operating Calling AI agents.

The Problem: The Telephony Gap

Traditional IVR systems and contact center platforms were never designed for the era of Large Language Models (LLMs). When developers try to build modern calling agents, they encounter three primary friction points:

Complexity: Each project requires re-implementing SIP trunk provisioning, room orchestration, and VAD (Voice Activity Detection) tuning.
Vendor Lock-in: Most "Voice AI" platforms tie you to a single stack, making it impossible to swap LLM or TTS providers as technology evolves.
Operation Hurdles: Features like call recording, metadata persistence, and transcription handling are often treated as afterthoughts rather than first-class features.

The Solution: A Unified Calling Abstraction

SIPHON sits between the telephony world and the AI world, providing a coherent framework for developers to build production-ready agents in ~30 lines of code.

How it Works: The SIPHON Architecture

Unlike generic voice frameworks, SIPHON is built on top of LiveKit, leveraging its real-time media and SIP layer to ensure high reliability.

The diagram illustrates how SIPHON orchestrates the entire call lifecycle:

PSTN/SIP Provider ↔ LiveKit SIP Domain (Real-time media)
LiveKit Rooms ↔ SIPHON Agent Worker (Orchestration)
SIPHON Worker ↔ AI Providers (OpenAI, Deepgram, Cartesia, etc.)

The framework is divided into two core modules:

siphon.telephony: Handles inbound Dispatch rules and outbound Call initiation, allowing you to bind phone numbers to agents programmatically.
siphon.agent: The runner that manages the LiveKit Agent worker, entrypoint orchestration, and the dynamic construction of AI components.

Key Pillars of SIPHON

1. Production-Ready at Scale

SIPHON is not a "toy" framework. It is designed for horizontal scalability; you can run your agent on one server or a thousand, and the architecture automatically balances the load.

2. Sub-500ms Latency

By utilizing WebRTC for real-time media interactions, SIPHON ensures voice interactions feel natural. It manages audio packet loss and interruptions to maintain a human-like flow.

3. Total Vendor Flexibility

Through its plugin architecture, SIPHON is agnostic to your AI stack. You can swap between OpenAI, Gemini, Deepgram, or ElevenLabs with minimal code changes.

4. Integrated Data Persistence

Recording, transcription, and metadata persistence are enabled via simple environment flags. Whether you need to save to S3, Postgres, or Redis, SIPHON handles the storage logic for you.

Getting Started

SIPHON is now open-source under the Apache 2.0 license.

Developers can install the framework and spin up a functioning agent worker in minutes:

pip install siphon-ai

Whether you are building an AI receptionist, an outbound notification system, or a contact-center triage bot, SIPHON provides the infrastructure to get you to production faster.

Stop building the plumbing. Start building the agent.

📚 Read the Documentation | ⭐ Star us on GitHub

A BLACKDWARF Initiative.

Hello, World. Meet SIPHON.

BLACKDWARF — Sun, 25 Jan 2026 11:21:45 +0000

Building an AI that chats is easy. Building an AI that calls is painfully hard.

If you have ever tried to build a production-ready voice agent, you know the struggle: fighting with SIP signaling, debugging audio buffers, and wrestling with 2-second latency.

We got tired of the plumbing. So we built SIPHON.

What is it?

SIPHON is an open-source Python framework for building Calling AI agents.

It is a "telephony-first" abstraction over LiveKit that handles the chaos of real-world phone networks for you. No more stitching together WebSockets or media servers. Just pure Python.

Why use it?

Production Ready:
Built for real phone calls, not just demos.
Few Lines of Code:
Spin up an agent that handles inbound/outbound calls in minutes.
Vendor Agnostic:
Swap LLMs (OpenAI, Gemini) and Voice providers (Deepgram, Cartesia) with a single config line.
Sub-500ms Latency:
Powered by WebRTC for conversations that feel human.
Zero-Config Horizontal Scaling:
Run your agent on multiple servers and it automatically load balances calls across them—no complex setup required.

Get Started

Install it:

pip install siphon-ai

Build your agent:

from siphon.agent import Agent
from siphon.plugins import openai, cartesia, deepgram

agent = Agent(
    agent_name="Receptionist",
    llm=openai.LLM(),
    tts=cartesia.TTS(),
    stt=deepgram.STT(),
)

if __name__ == "__main__":
    agent.dev()

The plumbing is done. Go build the agent.

⭐ Star us on GitHub | 📚 Read the Docs

We Open-Sourced Our AI Calling Framework (So You Don't Waste 2-3 Months)

BLACKDWARF — Sat, 17 Jan 2026 10:32:55 +0000

Three months.
That’s how long many teams spend building telephony infrastructure before writing a single line of actual conversation logic for an AI voice agent.

Not because the AI was hard.
Because telephony is brutal.

Today, we’re open-sourcing the solution so you don’t have to go through the same pain.

The Hidden Problem with AI Calling Agents

Building an AI calling agent sounds straightforward:

Use an LLM
Add speech-to-text
Add text-to-speech
Connect it to a phone number

In reality, that’s where most teams hit a wall.

To make real phone calls, you end up dealing with:

SIP trunks & PSTN providers
Low-latency, bidirectional audio
Real-time orchestration of STT, LLM, and TTS
Call state, interruptions, transfers
Scaling, monitoring, recordings, persistence

The result?
Most teams spend weeks or months on infrastructure before they ever touch the conversation itself.

We did too. And eventually asked:

“Why is building voice AI still this hard?”

Introducing Siphon

Siphon is an open-source Python framework that handles the telephony complexity for you, so you can focus on building great conversations.

Here’s what a complete AI receptionist looks like with Siphon:

from siphon.agent import Agent
from siphon.plugins import openai, cartesia, deepgram

agent = Agent(
    agent_name="receptionist",
    llm=openai.LLM(model="gpt-4"),
    tts=cartesia.TTS(voice="helpful-assistant"),
    stt=deepgram.STT(model="nova-2"),
    system_instructions="""
    You are a friendly receptionist for Acme Corp.
    Help callers schedule appointments or route them correctly.
    """
)

if __name__ == "__main__":
    agent.start()

Run this, and your agent can answer real phone calls via any SIP provider (Twilio, Telnyx, etc.).

What Siphon Handles for You

🔌 SIP & PSTN connectivity
Works with any SIP provider, no FreeSWITCH pain.
⚡ Real-time audio pipeline
Built on LiveKit with streaming audio and sub-500ms voice-to-voice latency.
🤖 AI orchestration
Plug-and-play support for LLMs, STT, and TTS.

Swap providers with a single line:

  llm=anthropic.LLM(model="claude-3-5-sonnet")

📈 Production-ready by default Auto-scaling, call recordings, transcripts, state handling, and observability.

Quick Start

Install:

pip install siphon-ai

Create an agent:

from siphon.agent import Agent
from siphon.plugins import openai, cartesia, deepgram

agent = Agent(
    agent_name="my_first_agent",
    llm=openai.LLM(),
    tts=cartesia.TTS(),
    stt=deepgram.STT(),
    system_instructions="You are a helpful assistant.",
)

agent.start()

That’s it.
Your agent is live and answering phone calls.

(Full setup, outbound calling, and advanced examples are in the docs.)

Why We Open-Sourced It

We could’ve kept Siphon proprietary or turned it into a closed SaaS.

But we believe voice AI shouldn’t be locked behind massive infrastructure effort.

Siphon is:

Apache 2.0 licensed
Provider-agnostic
Fully self-hostable
No vendor lock-in

Use it commercially, modify it, or build on top of it.

What You Can Build

📞 Customer support agents
📅 Appointment scheduling
💼 Sales qualification
📊 Surveys & feedback collection
🏥 Healthcare intake systems

If it involves phone calls and conversations, Siphon handles the hard parts.

Get Involved

⭐ GitHub: https://github.com/blackdwarftech/siphon
📖 Docs: https://siphon.blackdwarf.in/docs
🐛 Issues & feature requests welcome
🤝 PRs encouraged

We’re building Siphon in public and would love community feedback.

If you’ve ever thought

“I wish building AI calling agents was simpler”

— give Siphon a try.

Built by BLACKDWARF
Mission: Democratize complex technologies for developers.