Open Source · MIT License · Built with Rust

Your org's knowledge, collected.
Connected. Alive.

DocBrain ingests your scattered documentation — Confluence, GitHub, Slack, Jira — and turns it into an AI-powered knowledge system that answers questions with citations, learns from feedback, and tells you what's missing.

docbrain — terminal
# oncall-prod
SP
Sarah Park2:14 AM
/docbrain ask "redis OOM errors in payments-cache cluster"
DocBrain
DocBrainAPP2:14 AM
Redis OOM Troubleshooting — payments-cache
✓ Freshness: 3 days   Confidence: 88%
1. Check current memory: redis-cli -h payments-cache info memory
2. If maxmemory is hit, set eviction policy: allkeys-lru
3. Monitor eviction rate via Grafana → Redis dashboard → OPS-REDIS-001
📎 Sources: [1] Redis Configuration Guide [2] Payments Cache Runbook
👍 3 🎯 1
deploy.tf — infra/modules/rds — Cursor
deploy.tf
variables.tf
resource "aws_db_instance" "main" {
  engine         = "postgres"
  engine_version = "16.2"
  instance_class = "db.r7g.xlarge"
  multi_az      = true
  // ...
}
resource "aws_db_instance" "replica" {
  replicate_source_db = aws_db_instance.main.id
  
}

Collects knowledge from everywhere your team works

Confluence
GitHub
Slack
Jira
GitLab
MS Teams
Local Files
PagerDuty
Opsgenie
Linear
Zendesk
Intercom
Confluence
GitHub
Slack
Jira
GitLab
MS Teams
Local Files
PagerDuty
Opsgenie
Linear
Zendesk
Intercom

Your documentation is broken

Engineers waste 30-60 minutes a day searching for answers that exist somewhere. DocBrain fixes the three root causes.

Scattered everywhere

Confluence, GitHub wikis, Notion, Google Docs, Slack threads, Jira comments. Knowledge lives in 7+ tools. Nobody knows where to look.

Same questions, daily

"How do I deploy to staging?" gets asked in Slack every week. Someone answers. Nobody writes it down. The cycle repeats.

Docs rot silently

340 of your 800 Confluence pages haven't been touched in a year. Nobody knows which ones are accurate until someone follows outdated steps at 2am.

How It Works

From scattered docs to instant answers

A four-phase pipeline that ingests, understands, answers, and learns — getting smarter with every question your team asks.

01

Ingest

Point DocBrain at your Confluence spaces, GitHub repos, Slack channels, Jira projects. It chunks, embeds, and indexes everything — including images.

02

Understand

Hybrid search (vector + keyword) finds the right chunks. Cross-document references pull in linked Jira tickets, PRs, and runbooks automatically.

03

Answer

Grounded answers with citations, freshness badges, and confidence scores. No hallucination — every claim traces to a source document.

04

Learn

Every thumbs-up and thumbs-down trains the system. Procedural memory learns which docs answer which types of questions. It literally gets smarter.

4-Layer Memory System

A brain that
remembers everything

Inspired by cognitive science. Four memory layers work together so every question makes the system sharper. The 100th query about Kubernetes is faster and better-answered than the first.

~40%

Cache hit rate
(mature deploy)

<3s

Avg response
time

25MB

Binary size
(Rust)

Working Memory Redis

Multi-turn conversation context. Resolves "it", "that service", "the same thing" — so follow-up questions just work.

Episodic Memory Postgres + OpenSearch

Every Q&A ever asked. Enables semantic caching (skip the LLM on repeat questions) and learning from feedback. The system gets cheaper as it learns.

Semantic Memory Knowledge Graph

Entities and relationships extracted from your docs. "Who owns the payment service?" resolved via graph traversal, not keyword matching.

Procedural Memory Learned Rules

Adapts retrieval strategy from feedback. Learns: "deployment questions → search DevOps space first." Not configured — discovered.

Documentation Gaps Autopilot
Critical Redis OOM troubleshooting 12 queries · 8 users
High Secret rotation procedure 9 queries · 6 users
High Integration test without PR 7 queries · 5 users
Medium Staging environment access 4 queries · 3 users
4 gaps detected from 847 queries (30 days)

Autopilot

Finds what's missing
before you do

Most documentation tools serve what exists. DocBrain tells you what doesn't exist yet — by clustering low-confidence queries and negative feedback into actionable gaps.

  • Clusters related failed queries using cosine similarity
  • Scores severity by unique users, volume, and feedback ratio
  • Auto-drafts documentation grounded in your existing docs
  • Publishes to Confluence with one click — gap auto-resolves on ingest

Access Everywhere

Meets you where you work

One knowledge layer, five interfaces. Ask from Slack during an incident, from your IDE while coding, or from the terminal at 2am.

Slack

/docbrain ask

Web UI

Dashboard + chat

CLI

docbrain ask

MCP (IDE)

Cursor · Claude

REST API

Build anything

Features

Everything you need

Hybrid Search

Vector similarity + BM25 keyword in a single query. Catches both semantic meaning and exact matches like error codes and service names.

Cited Answers

Every claim traces to a source document. No hallucination. Phantom citations are stripped. Trust what you read.

Freshness Scoring

Every answer shows a freshness badge. Stale docs get flagged. Authors get notified when their high-traffic page is 14 months old.

Knowledge Graph

Entities and relationships extracted from your docs. "Who owns the payment service?" resolves through graph traversal, not keyword guessing.

Cross-Doc References

Slack thread links to a PR, PR references a Jira ticket, Jira points to a runbook. DocBrain follows the chain and enriches every answer.

SSO & RBAC

OIDC, GitHub OAuth, GitLab OIDC. Three roles: viewer, editor, admin. Role mapping from IdP claims. API keys are Argon2-hashed.

Provider Agnostic

Anthropic, AWS Bedrock, OpenAI, or Ollama (fully local). Swap LLM providers via config — zero code changes. No vendor lock-in.

Built with Rust

Single 25MB static binary. Starts in <500ms. Under 100MB memory at load. Runs on 2 vCPUs. No Python virtualenv, no node_modules.

Self-Hosted

Your data never leaves your infrastructure. Docker Compose for dev, Helm chart for production Kubernetes. MIT licensed.

The Complete Loop

Documentation that improves itself

Every question is a signal. Every answer gets feedback. Every gap becomes a draft. Every draft becomes a doc. The loop closes automatically.

01 Users ask questions
02 Gaps detected
03 Draft generated
04 Admin reviews
05 Published & re-ingested

Next user gets the answer. Loop closed.

Self-host in 5 minutes

Docker, an API key, and three commands. That's it.

quickstart
$ git clone https://github.com/docbrain-ai/docbrain
$ cd docbrain
$ bash scripts/setup.sh
✓ Created .env with defaults
✓ Started PostgreSQL, OpenSearch, Redis
✓ Ran 43 migrations
✓ Ingested sample docs
✓ Server running at http://localhost:3000
✓ Web UI at http://localhost:3001
Bootstrap admin key: db_sk_boot_...
$ open http://localhost:3001