Connapse

The knowledge backend for AI agents. Open-source, container-isolated, hybrid search.

Upload documents and search your knowledge base with hybrid AI search — in seconds.

Connapse is an open-source platform that turns your documents into searchable, AI-ready knowledge — organized in isolated containers, each with its own vector index and search configuration. Point it at your existing S3 buckets, Azure Blob containers, or local filesystems. Connect it to Claude via MCP — agents can both query your knowledge base and build their own research corpus by uploading and organizing documents. Use the REST API, web UI, or CLI. Built on .NET 10 — not another Python monolith.

📦 Quick Start

git clone https://github.com/Destrayon/Connapse.git && cd Connapse && docker-compose up -d
# Open http://localhost:5001

Prerequisites

• Docker & Docker Compose
• .NET 10 SDK (for development)
• (Optional) Ollama for local embeddings

Run with Docker Compose

# Clone the repository
git clone https://github.com/Destrayon/Connapse.git
cd Connapse

# Set required auth environment variables (or use a .env file)
export CONNAPSE_ADMIN_EMAIL=admin@example.com
export CONNAPSE_ADMIN_PASSWORD=YourSecurePassword123!
export Identity__Jwt__Secret=$(openssl rand -base64 64)

# Start all services (PostgreSQL, MinIO, Web App)
docker-compose up -d

# Open http://localhost:5001 — log in with the admin credentials above

The first run will:

1. Pull Docker images (~2-5 minutes)
2. Initialize PostgreSQL with pgvector extension and run EF Core migrations
3. Create MinIO buckets
4. Seed the admin account (from env vars) and start the web application

Development Setup

# Start infrastructure only (database + object storage)
docker-compose up -d postgres minio

# Run the web app locally
dotnet run --project src/Connapse.Web

# Run all tests
dotnet test

# Run just unit tests
dotnet test --filter "Category=Unit"

Using the CLI

Install the CLI (choose one option):

# Option A: .NET Global Tool (requires .NET 10)
dotnet tool install -g Connapse.CLI

# Option B: Download native binary from GitHub Releases (no .NET required)
# https://github.com/Destrayon/Connapse/releases

Basic usage:

# Authenticate first
connapse auth login --url https://localhost:5001

# Create a container (project)
connapse container create my-project --description "My knowledge base"

# Upload files
connapse upload ./documents --container my-project

# Search
connapse search "your query" --container my-project

# Update to latest release (--pre to include alpha/pre-release builds)
connapse update
connapse update --pre

Using with Claude (MCP)

Connapse includes a Model Context Protocol (MCP) server for integration with Claude and any MCP client.

Setup:

1. Create an Agent in the Connapse UI (/admin/agents) and generate an API key
2. Configure Claude to send requests to your Connapse instance with the agent's X-Api-Key

The MCP server exposes 11 tools:

Write guards: S3 and AzureBlob containers are read-only (synced from source). Filesystem containers respect per-container permission flags. Upload and delete tools will return an error for containers that block writes.

🚀 Features

• 🗂️ Container-Isolated Knowledge — Each project gets its own vector index, storage connector, and search configuration. No cross-contamination between projects, teams, or clients.
• 🔍 Hybrid Search — Vector similarity + keyword full-text with configurable fusion (convex combination, DBSF, AutoCut). Get results that pure vector search misses.
• 🧠 Multi-Provider AI — Swap between Ollama, OpenAI, Azure OpenAI, and Anthropic for both embeddings and LLM — at runtime, per container, without restarting.
• 🔌 Index Your Existing Storage — Connect MinIO, local filesystem (live file watching), S3 (IAM auth), or Azure Blob (managed identity). Your files stay where they are.
• 🤖 4 Access Surfaces — Web UI, REST API, CLI (native binaries), and MCP server (11 tools for Claude). Built for humans, scripts, and AI agents equally.
• 🔐 Enterprise Auth — Three-tier RBAC (Cookie + PAT + JWT) with AWS IAM Identity Center and Azure AD identity linking. Cloud permissions are the source of truth.
• 🐳 One-Command Deploy — Docker Compose with PostgreSQL + pgvector, MinIO, and optional Ollama. Structured audit logging and rate limiting built in.

🎯 Who Is Connapse For?

• AI agent developers who need a knowledge backend their agents can both query and build — upload research, curate a corpus, and search it via MCP or REST API
• .NET / Azure teams who want a RAG platform that fits their existing stack and cloud identity
• Enterprise teams who need project-isolated knowledge bases with proper RBAC and audit trails
• Anyone tired of re-uploading files — point Connapse at your existing S3/Azure/filesystem storage

🏗️ Architecture

┌─────────────────────────────────────────────────────────────┐
│                     Access Surfaces                         │
│  Web UI (Blazor)  │  REST API  │  CLI  │  MCP Server       │
└────────────┬────────────────────────────────────────────────┘
             │
┌────────────▼────────────────────────────────────────────────┐
│                   Core Services Layer                        │
│  Document Store  │  Vector Store  │  Search  │  Ingestion  │
└────────────┬────────────────────────────────────────────────┘
             │
┌────────────▼────────────────────────────────────────────────┐
│                    Connectors Layer                           │
│  MinIO  │  Filesystem  │  S3  │  Azure Blob               │
└────────────┬────────────────────────────────────────────────┘
             │
┌────────────▼────────────────────────────────────────────────┐
│                    Infrastructure                            │
│  PostgreSQL+pgvector  │  MinIO (S3)  │  Ollama (optional)  │
└─────────────────────────────────────────────────────────────┘

Data Flow: Upload → Search

[Upload] → [Parse] → [Chunk] → [Embed] → [Store] → [Searchable]
              ↓
         [Metadata]
              ↓
        [Document Store]

Target: < 30 seconds from upload to searchable.

Key Technologies:

• Database: PostgreSQL 17 + pgvector for vector embeddings
• Object Storage: MinIO (S3-compatible) for original files
• Backend: ASP.NET Core 10 Minimal APIs
• Frontend: Blazor Server (interactive mode)
• Embeddings: Ollama (default), OpenAI, Azure OpenAI (configurable)
• LLM: Ollama, OpenAI, Azure OpenAI, Anthropic (configurable)
• Search: Hybrid vector + keyword with convex combination fusion
• Connectors: MinIO, Filesystem, S3, Azure Blob

📚 Documentation

• Architecture Guide - System design and component overview
• API Reference - REST API endpoints and examples
• Connectors Guide - Connector types, configuration, and background sync
• AWS SSO Setup - AWS IAM Identity Center integration
• Azure Identity Setup - Azure AD OAuth2+PKCE integration
• Deployment Guide - Docker and production setup
• Security Policy - Security limitations and roadmap
• Contributing Guidelines - How to contribute

🗺️ Roadmap

Connapse is pre-1.0. Major design work is tracked in Discussions.

v0.1.0 — Foundation (Complete)

• ✅ Document ingestion pipeline (PDF, Office, Markdown, text)
• ✅ Hybrid search (vector + keyword with convex combination fusion)
• ✅ Container-based file browser with folders
• ✅ Web UI, REST API, CLI, MCP server

v0.2.0 — Security & Auth (Complete)

• ✅ Three-tier auth: Cookie + Personal Access Tokens + JWT (HS256)
• ✅ Role-based access control (Admin / Editor / Viewer / Agent)
• ✅ Invite-only user registration (admin-controlled)
• ✅ First-class agent entities with API key lifecycle
• ✅ Agent management UI + PAT management UI
• ✅ Audit logging (uploads, deletes, container operations)
• ✅ CLI auth commands (auth login, auth whoami, auth pat)
• ✅ GitHub Actions release pipeline (native binaries + NuGet tool)
• ✅ 256 passing tests (unit + integration)

v0.3.0 — Connector Architecture (Complete)

• ✅ 4 connector types: MinIO, Filesystem (FileSystemWatcher), S3 (IAM-only), Azure Blob (managed identity)
• ✅ Per-container settings overrides (chunking, embedding, search, upload)
• ✅ Cloud identity linking: AWS IAM Identity Center (device auth flow) + Azure AD (OAuth2+PKCE)
• ✅ IAM-derived scope enforcement — cloud permissions are the source of truth
• ✅ Multi-provider embeddings: Ollama, OpenAI, Azure OpenAI
• ✅ Multi-provider LLM: Ollama, OpenAI, Azure OpenAI, Anthropic
• ✅ Multi-dimension vector support with partial IVFFlat indexes per model
• ✅ Cross-model search: automatic Semantic→Hybrid fallback for legacy vectors
• ✅ Background sync: FileSystemWatcher for local, 5-min polling for cloud containers
• ✅ Connection testing for all providers (S3, Azure Blob, MinIO, LLM, embeddings, AWS SSO, Azure AD)
• ✅ 457 passing tests (unit + integration)

Future

• v0.4.0: Communication connectors (Slack, Discord)
• v0.5.0: Knowledge platform connectors (Notion, Confluence, GitHub)
• v1.0.0: Production-ready stable release

🤝 Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

Quick contribution checklist:

• Fork the repo and create a feature branch
• Follow code conventions in CONTRIBUTING.md
• Write tests for new features (xUnit + FluentAssertions)
• Ensure all tests pass: dotnet test
• Update documentation if needed
• Submit a pull request

Good first issues: Check issues labeled good-first-issue

📄 License

This project is licensed under the MIT License - see LICENSE for details.

You are free to:

• ✅ Use commercially
• ✅ Modify
• ✅ Distribute
• ✅ Sublicense
• ✅ Use privately

The only requirement is to include the copyright notice and license in any substantial portions of the software.

💬 Support & Community

• 📖 Documentation: docs/
• 🐛 Bug Reports: GitHub Issues
• 💡 Feature Requests: GitHub Discussions
• 🔒 Security Issues: See SECURITY.md

🙏 Acknowledgments

Built with:

• .NET - Application framework
• Blazor - Web UI
• PostgreSQL + pgvector - Vector database
• MinIO - S3-compatible object storage
• Ollama - Local LLM inference

⭐ If you find this project useful, please star the repository to show your support!