AI-Powered Codebase Intelligence
AutoDoc crawls your entire codebase, analyzes every file with AST parsing and a local LLM, builds a Neo4j knowledge graph of your architecture, and produces comprehensive documentation — without a human writing a single line of it.
Every engineering team has the same problem: documentation falls behind the moment it's written. Six months later, nobody knows how the system actually works. The people who built it leave. The knowledge walks out the door.
Critical system knowledge lives in people's heads, not in documentation. When they leave, the knowledge leaves with them. AutoDoc extracts and preserves it permanently.
Docs written once and never updated are worse than no docs — they actively mislead. AutoDoc re-analyzes on every run and only updates what's changed.
Which file imports which module? Which service writes to which table? Without a graph, these relationships are invisible until something breaks. AutoDoc maps them all.
New engineers spend weeks asking "how does this work?" and "where does that live?" AutoDoc produces the answers before they ask the questions.
AutoDoc runs as a single CLI command. It's resumable — if interrupted, it picks up where it left off. Every phase produces durable output.
Walk the codebase. Identify every documentable file — Python, JavaScript, shell, SQL, YAML, configs, Dockerfiles, systemd units. Skip binaries, caches, and vendor dirs. Hash every file for change detection. Group by module and development stream.
AST-parse Python files to extract classes, functions, decorators, imports, FastAPI routes, and database references. Scan systemd services. Query PostgreSQL for table inventory. Query Neo4j for label inventory. Build the full structural graph in Neo4j with typed nodes and relationships.
Send each file to a local LLM with its AST context. The model produces per-file documentation: purpose, architecture, patterns, dependencies, interfaces, database usage, configuration, key logic, and integration points. All analysis happens on your hardware — no cloud calls.
Gather per-file analyses by module. A synthesis model reads all file docs in a module and produces a module-level overview — how the pieces fit together, data flow, key components, design patterns, and the module's API surface.
Roll module summaries up into development stream overviews. Each stream document explains the stream's overall purpose, how its modules interact, and the architectural patterns that hold them together.
The final synthesis: all stream overviews are fed to the LLM to produce a master system architecture document. This is the single document that explains how the entire system works, end to end.
Produce a searchable index — both JSON for programmatic access and Markdown for human reading. Every file, every module, every stream, linked to its documentation. The complete map of your codebase.
AutoDoc doesn't just produce text files. It builds a queryable knowledge graph of your system in Neo4j. Every file, function, class, API endpoint, database table, service, and module becomes a node. Import relationships, function containment, table references, and stream ownership become edges. Ask questions like "which files reference the transactions table?" or "what does the finance module depend on?" and get answers from the graph.
Every source file gets its own markdown document — purpose, architecture, patterns, dependencies, interfaces, and key logic.
Each module gets a synthesized overview showing how its files work together, data flow, design patterns, and API surface.
One master document explaining the entire system — how all streams, modules, and services connect. The document your team has always needed.
AutoDoc is deployed on your infrastructure, pointed at your codebase, and run on your schedule. The output is yours — markdown files, Neo4j graph, and JSON index. No subscription, no cloud dependency, no vendor lock-in.
Start a Conversation