docbrain

Project Status: client source open, server closed. The source for everything DocBrain runs on your side of the network boundary — the docbrain CLI and the IDE MCP server — is in this repo under crates/, MIT-licensed, built and tested in public CI. Audit exactly what runs in your environment and what leaves it. The server ships as free production Docker images (BSL 1.1 permits production use) with full Helm charts, complete configuration, the threat model, and all the docs to self-host in production. The server source stays closed for now — we originally targeted the first half of 2026 to publish it, we missed that date, and we won't post a new date until we're certain we can hit it. If a closed server is a dealbreaker for you, that's a rational position and we respect it: how DocBrain earns trust. Contributions: code PRs for the client crates, plus documentation, configuration, and bug reports. When the server source publishes, it will be under the BSL 1.1 terms below.

The Problem

Every organization runs on knowledge that never gets written down: the decision from a meeting, the fix someone found at 2am, the workaround only one person knows. It lives in PRs, chat threads, tickets, and people's heads. When that person changes teams or quits, years of context walk out the door with them.

Tools that "index your docs and add a chatbot" solve the wrong half of the problem: they retrieve your stale, incomplete wiki slightly faster. The knowledge that actually runs your organization was never captured in the first place. And it's getting worse now that AI produces code, changes, and fluent documentation faster than any human can absorb — your agents read those docs too. More documentation is easy. Documentation your organization can trust is the scarce thing.

Related MCP server: MCPDocSearch

How DocBrain Works

DocBrain captures knowledge at the source, the moment it's created:

  Someone merges a change      ──→  decisions, caveats, procedures extracted
  A team works through chat    ──→  the answer, distilled from the thread
  A deploy goes out            ──→  what changed and why
  On-call resolves an incident ──→  the fix and the root cause
  Any other system you run     ──→  ingested via the Connector SDK

Captured fragments are confidence-scored, connected into one memory, and composed into documentation with per-claim provenance. Drafts route through human review before anything publishes. Then DocBrain keeps the result honest: freshness tracking, contradiction detection, and staleness alerts as reality changes. Ask a question, get a cited answer — or an honest "I don't know" instead of a guess.

Quickstart

git clone https://github.com/docbrain-ai/docbrain.git && cd docbrain
./scripts/setup.sh    # interactive wizard: picks provider, sets keys, starts services

Or manually:

cp .env.example .env   # set LLM_PROVIDER and API keys
docker compose up -d

# Get the auto-generated admin API key
docker compose exec server cat /app/admin-bootstrap-key.txt

# Open the web dashboard
open http://localhost:3001

# Or ask a question via API
curl -H "Authorization: Bearer <key>" \
     -H "Content-Type: application/json" \
     -d '{"question":"How do I deploy to production?"}' \
     http://localhost:3001/api/v1/ask

Full setup guide: docs/quickstart.md

Teach Your Agent

If your team uses Claude Code or Cursor, the docbrain-mcp server already gives your agent capture tools — most teams just never tell the agent to use them. Three lines in your CLAUDE.md turn every debugging session into documentation:

When we resolve an error or discover non-obvious behavior, call
docbrain_suggest_capture for the files involved. If a gap exists, draft a
3–5 line capture and ask me to approve it before calling docbrain_capture.

Your agent fixes something, checks whether the org already knows it, and — with your approval — files what's missing into the review queue. The knowledge gets captured at the only moment it's free: seconds after the fix. Full guide, including Cursor setup and the privacy model: docs/agents.md

What You Get

• Capture from 13 built-in sources — Confluence, Slack, Teams, GitHub, GitLab, Jira, PagerDuty, Linear, OpsGenie, Rootly, Zendesk, Intercom, and local files, plus a language-agnostic Connector SDK for anything else. Ingestion guide →

• Ask, with citations — hybrid vector + keyword search, confidence-scored answers; low confidence asks clarifying questions instead of guessing. API →

• docbrain generate — on-demand docs grounded in your own runbooks, incidents, threads, and PRs, with per-claim provenance and honest needs_input for what the knowledge can't answer. Generate guide →

• Quality gates on every doc — structural, style (your style guide, enforced automatically), and semantic scoring; nothing unscored enters the system. Style policy →

• Review workflows and ownership — multi-stage approvals, space owners, SLAs, and governance dashboards, so documentation has accountability. Governance → · Reviews →

• Autopilot — clusters unanswered questions into gaps, drafts grounded fixes, and routes them to human review. Nothing publishes without oversight. Autopilot →

• Freshness and contradiction detection — stale docs flagged, conflicting docs surfaced, cascade staleness traced across dependent docs. Knowledge intelligence →

• Source-system ACL mirroring — Confluence restrictions, Slack channel membership, and repo visibility enforced at query time. Access control →

• RBAC, SSO, audit logging — 4-tier roles, GitHub/GitLab/OIDC SSO, per-space isolation. RBAC →

• Everywhere your team works — web dashboard, Slack commands, CLI, CI hooks, and MCP tools for Claude Code, Cursor, and any MCP-compatible editor. Slack →

Architecture

graph TB
    subgraph "Capture Layer"
        CI["CI/CD Pipelines"]
        IDE["IDE (MCP)"]
        SLACK["Slack / Teams"]
        WEB["Web UI"]
        CLI["CLI"]
        API_EXT["External APIs"]
    end

    subgraph "DocBrain Server (Rust / Axum)"
        FRAG["Fragment Router"]
        QUAL["Quality Pipeline"]
        CLUST["Clustering Engine"]
        COMP["Composition Engine"]
        REV["Review Workflows"]
        RAG["RAG Pipeline"]
        AUTO["Autopilot"]
        GOV["Governance"]
        EVT["Event Bus + Webhooks"]
    end

    subgraph "Storage"
        PG["PostgreSQL"]
        OS["OpenSearch<br/><i>vector + keyword</i>"]
        RD["Redis"]
    end

    CI & IDE & SLACK & WEB & CLI & API_EXT --> FRAG
    FRAG --> QUAL --> CLUST --> COMP --> REV
    WEB & CLI & SLACK --> RAG
    RAG & AUTO & GOV --> PG & OS
    EVT --> PG

Rust server, PostgreSQL, OpenSearch, Redis. Full design: docs/architecture.md

Security

DocBrain runs entirely in your infrastructure, read-only against your sources. You choose where the model runs: fully local via Ollama (zero egress), your own cloud account (Bedrock, Azure, Vertex — your KMS, your audit trail), or a provider API. Documents, embeddings, and indexes never leave your network; only the query and the relevant chunks reach the LLM you chose.

API keys are Argon2-hashed, every endpoint enforces RBAC, rate limits are per-key, and admin actions are audit-logged. The client code you install is open source in crates/. The full threat model — 11 analyzed attack vectors and an operator checklist — is published: THREAT_MODEL.md

LLM providers (14): Anthropic, OpenAI, AWS Bedrock, Ollama, Google Gemini, Vertex AI, Azure OpenAI, DeepSeek, Groq, Mistral, xAI, OpenRouter, Together AI, Cohere. Provider setup →

Deployment

# Docker Compose — everything behind a single origin at localhost:3001
docker compose up -d

# Kubernetes
helm install docbrain ./helm/docbrain \
  --set llm.provider=anthropic \
  --set llm.anthropicApiKey=sk-ant-...

Kubernetes guide → · Configuration →

Documentation

See It In Action

▶ The quickstart, recorded unedited — install → ingest → cited answer → generate turning raw on-call notes into a runbook that cites its sources. 90 seconds, shipped images, 100% local models, nothing staged.

Community

• GitHub Issues: Bug reports and feature requests

• GitHub Discussions: Questions and community conversation

• Email: hello@docbrainapi.com

Contributing

We welcome contributions. The client tooling source (crates/) accepts code PRs; server-side contributions land best as documentation, configuration, and bug reports. See Contributing Guide.

Security Reports

To report a security vulnerability, see SECURITY.md. Do not file a public issue.

License

Business Source License 1.1 (BSL 1.1). Production use is permitted, except offering DocBrain as a hosted service. Converts to Apache 2.0 on January 1, 2028. For alternative licensing: licensing@docbrainapi.com.

Code of Conduct

Contributor Covenant Code of Conduct. Report concerns to hello@docbrainapi.com.