Dendrite is Live
Living documentation that writes itself
Documentation is a lie.
Not intentionally. But the moment you write it, it starts decaying. Code changes, docs don't. Six months later, that README is actively harmful—teaching patterns that no longer exist.
I wanted documentation that couldn't rot.
The problem with docs
Every approach has the same failure mode:
READMEs — Written once, forgotten forever.
Wikis — Become graveyards of outdated information.
Docstrings — Too close to code to see the big picture.
Architecture docs — Obsolete before the PR merges.
The problem isn't writing docs. It's keeping them current. And humans are terrible at maintenance.
What if docs generated themselves?
Dendrite connects to your Git repository and builds a living wiki.
It parses your code. Understands the structure. Generates documentation that reflects what actually exists—not what someone remembered to write down.
Push a commit? Dendrite updates the docs.
Rename a method? The wiki reflects it.
Add a new controller? Documentation appears.
No manual work. No decay.
How it works
docker-compose up -d dendrite
# Connect a repository
# Dendrite clones, parses, and indexes
# Open http://dendrite.localhost
Dendrite uses tree-sitter to parse your code into an AST. It chunks the code intelligently—by class, by method, by logical unit.
Then it generates embeddings locally using MiniLM. No external API calls. Your code stays private.
Claude synthesizes the documentation, but your code never leaves your infrastructure.
The wiki
Dendrite generates:
Class documentation — What each class does, its responsibilities, its relationships.
Method documentation — Parameters, return values, behavior.
Architecture overview — How the pieces fit together.
Mermaid diagrams — Class diagrams, ER diagrams, sequence diagrams. Auto-generated.
Browse it like any wiki. Search it semantically. Ask questions about it.
Semantic code search
"Where is authentication handled?"
Dendrite doesn't grep for "auth". It understands meaning.
It finds the session controller, the JWT service, the middleware, the user model—all the pieces that touch authentication, even if they don't use that word.
Semantic search across your entire codebase.
Ask your code questions
This is the killer feature.
"How does the payment flow work?"
Dendrite searches your code semantically. Finds the relevant pieces. Synthesizes an explanation:
"Payments start in CheckoutsController#create, which calls PaymentService.process. The service validates the card via Stripe, creates a Payment record, and triggers OrderConfirmationJob. Failures are caught by PaymentErrorHandler which..."
Not documentation someone wrote. Documentation generated from what the code actually does.
MCP integration
Claude Code can query Dendrite directly:
dendrite_search("how do we handle webhooks")
dendrite_ask("explain the order fulfillment process")
AI-assisted development with full codebase context.
The philosophy
100% local. Except Claude API calls for generation.
Your code never hits external embedding services. Your repository stays on your machine.
Self-host it. Own your data.
Try it
Connect a repository. Watch the wiki generate itself.
Then ask it a question about your code. See how fast you get an answer.
This is what documentation should have been all along.
— Andres