Rapida: End-to-End Voice Orchestration Platform

Rapida is an open-source voice AI orchestration platform for agencies that need ownership and enterprises that need scale, control, and deploy-anywhere flexibility.
It’s built around three core principles:

• Ownership — run managed or self-hosted while keeping control of data, credentials, branding, and deployment boundaries
• Control — choose your models, prompts, tools, and integrations without vendor lock-in
• Scale — operate real-time voice workloads with observability, governance, and production-grade reliability

Rapida provides both a platform and a framework for teams building white-label client deployments, internal AI operations, and enterprise voice infrastructure.

Rapida is written in Go, using the highly optimized gRPC protocol for fast, efficient, bidirectional communication.

Architecture

Features

• Real-time Voice Orchestration
  Stream and process audio with low latency using gRPC.

• Ownership by Default
  Self-host or run managed while keeping control of infrastructure, credentials, and runtime behavior.

• Provider and Model Control
  Bring your own model—OpenAI, Anthropic, open-source models, or custom inference.

• Production-grade Reliability
  Built-in retries, error handling, call lifecycle management, and health checks.

• Full Observability
  Call logs, streaming events, tool traces, latency breakdowns, metrics, and dashboards.

• Governance-ready Tooling
  Build custom tools, lock down API surfaces, and manage deployments with audit-friendly controls.

• Built for Agencies and Enterprise
  Support multi-client delivery, private deployments, and large-scale internal operations from the same platform.

Documentation & Guides

Prerequisites

• Docker & Docker Compose (Install)
• Just command runner (Install)
• Go 1.25.13, Node.js 22, and Yarn 1.22.22 for just ci
• 16GB+ RAM (for all services)

Quick Start

Get all services running in 4 commands:

# Clone repo
git clone https://github.com/rapidaai/voice-ai.git && cd voice-ai

# Setup & build
just setup-local build-all

# Start all services
just up-all

# View running services
docker compose ps

Services Ready (just up-all):

• UI:
• API Gateway (nginx):
• Web API: internal-only by default (container network)
• Assistant API:
• Endpoint API:
• Integration API:

To include knowledge services (OpenSearch + Document API), run:

just up-all-with-knowledge

Then:

• Document API:

Stop services:

just down-all

Development

Continuous Integration and Build Packages

Run the same required checks used by pull requests from the repository root:

just ci

The command bootstraps its pinned Python, commitlint, and shellcheck tooling in local cache directories. Docker remains required for image, integration, and smoke-test stages.

After Continuous Integration succeeds for a push to main, GitHub creates an immutable tag named build-YYYYMMDD-. The matching GitHub prerelease contains packages for web-api, integration-api, endpoint-api, assistant-api, and ui, plus a SHA256SUMS file. The deprecated document-api is intentionally excluded from CI and release packaging.

Work on Specific Services

# Start only database
just up-db

# Start only UI
just up-ui

# Start only Assistant API
just up-assistant

# List all start commands
just --list

View Logs

# All services
just logs-all

# Specific service
just logs-web
just logs-assistant

Rebuild After Code Changes

# Rebuild and restart one service
just rebuild-assistant

# Rebuild all
just rebuild-all

Configure Services

Edit YAML config files before starting:

• docker/web-api/web.yml - Web API (port 9001)
• docker/assistant-api/assistant.yml - Assistant API (port 9007)
• docker/endpoint-api/endpoint.yml - Endpoint API (port 9005)
• docker/integration-api/integration.yml - Integration API (port 9004)
• docker/document-api/config.yaml - Document API (port 9010)

Add your API keys (OpenAI, Anthropic, Deepgram, Twilio, etc.) in these files.

Local Development (Without Docker)

Set up environment

• Install the nginx; Copy the nginx configuration from ./nginx/nginx.conf
• Review service configuration (database connection parameters, redis connection parameters)
• Create local storage path in /opt/rapida-data/assets/workflow and make sure it is writable by user

sudo mkdir -p /opt/rapida-data/assets/workflow
sudo chown -R "$USER:$(id -gn)" /opt/rapida-data/assets

Go Services

# Install dependencies
go mod download

# Build service
go build -o bin/web ./cmd/web

# Run service
./bin/web

Requires PostgreSQL, Redis, OpenSearch running separately.

React UI

# Complete local UI setup, test report, and Storybook build
just ui

# Run the UI app
just ui-dev

# Run Storybook
just ui-storybook

# Generate Allure and coverage reports, then view Allure
just ui-report
just ui-report-open

# Build for production
cd ui && yarn build

Troubleshooting

Port already in use:

lsof -i :3000    # Find process
kill -9     # Kill it

Services won't start:

just logs-all    # Check logs
docker compose ps  # Verify status

Database issues:

# Test connection
docker compose exec postgres psql -U rapida -d web_db -c "SELECT 1"

# Reset everything
just clean
just setup-local
just build-all
just up-all

All Commands

just --list         # Show all available commands
just setup-local    # Create data directories
just build-all      # Build all Docker images
just up-all         # Start all services
just down-all       # Stop all services
just logs-all       # View all logs
just clean          # Remove containers & volumes
just restart-all    # Restart all services

Run the same repository checks locally:

just ci-fast        # Go, UI, contracts, workflow, and tooling checks
just ci-integration # Build and verify the complete Docker stack
just ci-smoke       # Run API smoke tests against the complete stack
just ci             # Run every CI lane, including security and native-runtime checks

Contributing

See CONTRIBUTING.md for guidelines.

Want to add:

• New STT/TTS provider? Check api/assistant-api/internal/transformer/
• New telephony channel? Check api/assistant-api/internal/telephony/

SDKs & Tools

Client SDKs

Client SDKs enable your frontend to include interactive, multi-user experiences.

Server SDKs

Server SDKs enable your backend to build and manage agents.

Contributing

For those who'd like to contribute code, see our Contribution Guide. At the same time, please consider supporting RapidaAi by sharing it on social media and at events and conferences.

Security disclosure

To protect your privacy, please avoid posting security issues on GitHub. Instead, report issues to , and our team will respond with detailed answer.

License

Rapida is open-source under the GPL-2.0 license, with additional conditions:

• Open-source users must keep the Rapida logo visible in UI components.
• Future license terms may change; this does not affect released versions.

A commercial license is available for enterprise use, which allows:

• Removal of branding
• Closed-source usage
• Private modifications Contact for details.