Wavefront

What is Wavefront ?

Wavefront AI is an open-source middleware platform for building production AI applications on enterprise data. It lets you:

• Connect to databases, APIs and cloud storage, and query them with access control and audit logging
• Use any LLM or SLM, hosted or self-hosted
• Build agents, multi-agent workflows, chatbots and voice agents on top of that data, configured in YAML and versioned
• Add authentication, role-based access control, observability and evaluation to all of them

What people build with Wavefront ?

• AI agents and workflows that audit, underwrite, supervise contact centers and automate business processes
• Knowledge bases and RAG applications for internal enterprise use
• Voice agents for collections and sales, over inbound and outbound phone calls
• Chatbots that give each user a persistent conversation with a configured model
• Workflows that combine multiple data sources, knowledge bases and services

✨ Key Capabilities

• 🤖 Agents & Workflows
  Define agents and multi-agent workflows in YAML, built on flo-ai. Every save creates a new version, validated by building the agent or compiling the workflow, and you can promote or roll back versions. Workflows can reference saved agents, define agents inline, or embed other workflows. Run them synchronously with streamed events, or asynchronously on background workers.

• 💬 Chatbots & Sessions
  Configure a chatbot as a system prompt bound to a model. Each user gets persistent chat sessions with stored history and streaming replies. Sessions keep a snapshot of the prompt they started with, so editing a chatbot never rewrites past conversations.

• 🔊 Voice Agents
  Voice-to-voice agents for inbound and outbound phone calls, built on Pipecat. They support multiple languages, tool calls during a call, smart turn detection, and LLM-based evaluation after each call.

  • Telephony: Twilio, Exotel, Smartflo
  • Speech-to-text: Deepgram, AssemblyAI, Whisper, Google, Azure, Sarvam, ElevenLabs
  • Text-to-speech: ElevenLabs, Deepgram, Cartesia, Azure, Google, AWS, Sarvam

• 🌐 Data Connectivity
  Connect to BigQuery, Redshift, PostgreSQL and SQL Server as datasources. Read and write through an OData-style API, or define parameterised dynamic queries in YAML and run or export them. Every datasource operation is audit logged. API services connect any REST backend, with API key, Basic and Bearer authentication. Cloud storage works with AWS, GCP and Azure.

• 🧠 Knowledge Bases & RAG
  Upload documents to knowledge bases, with background ingestion and embedding. Retrieval combines vector (pgvector) and keyword search with reranking, and supports image search.

• 🛠️ Tools & Triggers
  Agents can use datasources, knowledge bases, API services, email and custom message processors as tools. Triggers start an agent or workflow from external events, starting with Gmail.

• 🤖 Open Source & Proprietary Model Support
  OpenAI, Azure OpenAI, Anthropic, Google Gemini, Groq, Ollama and vLLM, managed centrally as reusable model configurations. flo-ai also supports Vertex AI and AWS Bedrock.

• 🔐 Authentication & Authorization
  Email/password, Google OAuth, Microsoft OAuth (Entra) and Microsoft ADFS sign-in. Role-based access control with users, groups, roles and resources, plus account lockout and reCAPTCHA protection.

• 📊 Observability, Monitoring & Evaluation
  Built-in OpenTelemetry telemetry pushed to any APM backend — local Jaeger, Azure Application Insights, AWS X-Ray/CloudWatch, GCP Cloud Trace, or any OTLP-compatible vendor. See the OpenTelemetry guide.

• 🖥️ Web Console
  A web console for configuring agents, workflows, chatbots, voice agents, datasources, knowledge bases, triggers and model providers across all your applications.

Architecture

Each application runs as its own deployment, and a single console manages all of them.

                ┌──────────────────────────────┐
                │  floconsole                  │  manages apps, builders and access
                └──────┬───────────────┬───────┘
                       │               │
          ┌────────────▼───┐     ┌─────▼──────────┐
          │ floware (app A)│     │ floware (app B)│  one core server per application
          └────────────────┘     └────────────────┘

Because each application has its own floware, each gets its own database, storage and secrets.

Quick Start

Option 1: Schedule a demo and we help you build immediately.

Option 2: Self-host for maximum control and customization. Please find the self-hosting instructions in the Wavefront Documentation and the Docker setup guide.

Option 3: Run Wavefront locally for development with the interactive scripts.

Local development setup

wavefront/dev-start.sh sets up and starts selected services on your machine. wavefront/dev-stop.sh stops them (running ones are pre-checked). Both are safe to re-run: services that are already running are left as they are on start.

Prerequisites: Python 3.11+, uv, Docker (running), Node.js 20+, pnpm (corepack enable) and openssl. dev-start.sh checks for all of them first.

cd wavefront
./dev-start.sh   # first-time setup + start selected services
./dev-stop.sh    # stop selected services

dev-start.sh:

1. Lets you choose which apps to start (floconsole, floware, web client, celery, RAG ingestion, inference, call processing).
2. Creates each selected service's .env from its checked-in sample (.env.example / .env.sample). Existing .env files are kept by default; turn on replace .env files to recreate them (with a backup). Secrets such as PASSTHROUGH_SECRET are generated or synced across services.
3. Starts Postgres (pgvector), Redis and LocalStack with server/docker-compose.yml. LocalStack provides S3, SQS and KMS locally, so no cloud account is needed.
4. Creates the databases, the S3 bucket, the RAG ingestion queue and the KMS keys used to sign tokens.
5. Installs the Python dependencies into server/.venv and the web client's dependencies (when selected).
6. Starts each selected service in its own terminal window, and waits until it is healthy.

Optional services default to off in the checkbox. The inference app downloads its models (several GB) from Hugging Face on first run, and needs a Hugging Face token with access to the gated DINOv3 model. It runs on CPU on Linux and Apple Silicon Macs; with all three models loaded (CLIP, DINOv3 and BGE-M3) it needs roughly 4–5 GB of free memory. Intel Macs have no PyTorch build at the supported version (2.6 or later), so there it runs in mock mode: the same API returning synthetic embeddings, for integration testing, with no models to download. Set INFERENCE_MOCK_MODELS=true to use mock mode anywhere.

When the script finishes:

1. Open the web client at http://localhost:5173 and log in with the seed user from server/apps/floconsole/floconsole/.env (CONSOLE_EMAIL / CONSOLE_PASSWORD).
2. Add floware as an app: Apps → Create new app, with App Name localhost, Deployment Type Manual, and http://localhost:8001 as both the Public and Private URL. With VITE_APP_ENV=local in client/.env, you can tick “Create local app for development” to fill these in.
3. Start building.

To stop services, run ./dev-stop.sh (or close their terminal windows). To start again, re-run ./dev-start.sh.

Platform Components

Roadmap

See ROADMAP.md for detailed feature plans and contribution opportunities.

[!WARNING]

• This project is under active development and APIs may change without notice. Please checkout the platform docs for the latest information.
• The platform is not in the GA state, and there are unimplemented features. Checkout ROADMAP.md for the list of features, and what's missing.

⭐ Show Your Support

If you find Wavefront AI useful, please consider:

• Starring this repository ⭐
• Sharing with your network
• Contributing to the project
• Providing feedback and feature requests

Next Steps

• Join our Discord
• Read our docs
• Submit an issue
• Talk to us

Text us!