docmancer 0.6.6

Compress local documentation context for coding agents.

Your agents' memory, unified, local, and yours.

Install | First run | What you get | Wiki

---

Your coding agents (Claude Code, Codex, Cursor, Gemini, OpenCode, Cline, Windsurf, and more) already write memory, instructions, and rules all over this machine, each locked inside its own tool. Docmancer discovers all of it, syncs it into one local hybrid (lexical + dense) index, and lets you recall any past decision instantly and offline. The full memory loop is four steps:

1. Sync (docmancer memory sync): discover and index every agent's memory, instructions, and rules into one local SQLite index. Local, offline, no keys.
2. Recall (docmancer memory query): hybrid search across everything your agents have ever written, with source provenance.
3. Consolidate (docmancer memory consolidate): use the coding-agent CLI you already run to turn scattered, duplicated memory into one coherent, review-only master-memory draft.
4. Apply (docmancer memory apply): materialize the reviewed draft into an agent's always-loaded file, so the context loads every session with no tool call.

The same engine also does docs RAG as a secondary capability: point it at a folder of Markdown / PDF / DOCX / RTF / HTML or a docs URL (GitBook, Mintlify, generic web, GitHub) and query it the same way. A fresh install ships everything you need for the local path: SQLite FTS5 for lexical search, a static embedding model (potion-base-8M) vendored in the package so there is no large model download and no network at runtime, and sqlite-vec for dense vectors in a single local file with no daemon.

Install

pipx install docmancer    # Python 3.11, 3.12, or 3.13

If pipx picks an unsupported interpreter, pin one: pipx install docmancer --python python3.13.

First run

Two commands take you from a fresh install to recalling your agents' memory:

docmancer setup                                  # discovers and indexes the agent memory already on this machine
docmancer memory query "why did we pick Railway" # recall a past decision, offline

setup creates ~/.docmancer/ with the config and SQLite database, syncs the memory, instructions, and rules your coding agents already wrote (Claude Code, Codex, Cursor, Gemini, OpenCode, Cline, Windsurf, and more) plus repo-level CLAUDE.md / AGENTS.md / GEMINI.md, auto-detects installed agents, and installs their skill files. There is no large model download and no network at runtime: the static embedding model is vendored in the package.

Re-sync any time and see exactly what was indexed and from where:

docmancer memory sync                # discover, redact, and (re)index everything
docmancer memory sources             # provenance: agent, type, scope, title, path, char count
docmancer memory sources --preview   # live re-harvest (what WOULD index) without writing

Want docs RAG too? The same engine indexes documentation:

docmancer ingest ./docs                             # index local files
docmancer add https://docs.pytest.org               # or a docs URL
docmancer query "How do I parametrize a fixture?"   # hybrid search across the docs index

Consolidate and carry memory across agents

Syncing gives you one searchable index. Consolidation turns that pile into a single coherent memory. docmancer memory consolidate sends your retrieved local memory (privacy-redacted first) through an installed coding-agent CLI by default, using claude, codex, gemini, opencode, cline, copilot, or cursor-agent when one is available. It gets back a review-only master-memory draft: deduplicated, grouped into compact sections, with conflicts surfaced as warnings instead of silently resolved.

docmancer memory consolidate \
  --query "deployment and infra decisions" \
  --output master-memory-draft.md \
  --draft-quality fast \
  --timeout 180

Once you have reviewed the draft, materialize it into an agent's always-loaded file so the context loads every session with no tool call and, crucially, so memory written in one agent shows up in the others:

docmancer memory apply --agent codex   # uses master-memory-draft.md by default
docmancer memory apply --agent codex --dry-run   # preview the diff first

apply is local and keyless. It writes only inside a clearly delimited managed block, takes a timestamped backup first, and never touches your own surrounding content. --remove strips the block for a clean uninstall. This is the only command that writes consolidated memory into agent-owned files, and it is never automatic. (docmancer install codex / claude-code also inject a short recall instruction into the same files, in their own managed block.)

The default provider is agent, which auto-selects the first supported agent CLI on your PATH. Pass --provider claude, --provider codex, --provider gemini, --provider opencode, --provider cline, --provider github-copilot, or --provider cursor to force one. This is not offline: the selected agent may call Anthropic, OpenAI, Google, or another configured provider through that agent's own account.

OpenRouter is still available as the only direct cloud API fallback. When OPENROUTER_API_KEY is set, memory extract and memory consolidate automatically retry through OpenRouter if an agent CLI provider fails during setup, preflight, or generation. --model accepts any OpenRouter chat model id your account can use, including Mistral models, Anthropic models, OpenAI models, Google models, and others. Set DOCMANCER_OPENROUTER_MODEL to change the OpenRouter default from openai/gpt-4.1-nano.

export OPENROUTER_API_KEY=...
docmancer memory consolidate \
  --provider openrouter \
  --model mistralai/mistral-large-2512 \
  --output master-memory-draft.md \
  --yes

Use --timeout, DOCMANCER_AGENT_CLI_TIMEOUT_SECONDS, or DOCMANCER_OPENROUTER_TIMEOUT_SECONDS to bound each provider request, with a finite 180 second default and 0 for the provider default. Every provider-backed command fails gracefully with a clear message when both the selected agent and OpenRouter fallback are unavailable, prints a provider-use notice before the first call, runs a preflight before large memory payloads, logs each request before sending it, and runs secret redaction before any text leaves your machine. See the Configuration and Commands pages for details.

What you get

Your agents' memory, unified. docmancer memory sync discovers and indexes the memory, instructions, and rules your coding agents already wrote (Claude Code, Codex, Cursor, Gemini, OpenCode, Cline, Windsurf, and more, plus repo-level CLAUDE.md / AGENTS.md / GEMINI.md), then answers questions about them through one local index. docmancer memory sources shows exact provenance per file. The local path uploads nothing.

Consolidate with the agents you already run. docmancer memory consolidate turns the scattered index into one review-only master-memory draft via an installed coding-agent CLI by default, and docmancer memory apply bakes the reviewed result into an agent's always-loaded file so context carries across agents. OpenRouter is available with --provider openrouter when you want a direct API key path or a specific OpenRouter model id, and it is used automatically as a fallback when an agent provider fails and OPENROUTER_API_KEY is set.

Callable over MCP. The packaged docmancer-mcp stdio server exposes local memory and docs search to MCP clients. docmancer mcp install codex (or claude-code, claude-desktop) wires it up; optional OpenRouter tools appear when OPENROUTER_API_KEY is set. Requires the mcp extra.

Hybrid search by default. query and memory query fan out across SQLite FTS5 (lexical, BM25-reranked) and dense vectors from a vendored static model (potion-base-8M) in sqlite-vec, then fuse results with Reciprocal Rank Fusion. Sparse (SPLADE) signals are available on the optional heavy Qdrant backend. The token budget keeps responses small so your agent has room for actual work:

Context pack: ~900 tokens vs ~4800 raw docs tokens (81.2% less docs overhead, 5.33x agentic runway)

No large model download, offline at runtime. The static embedding model ships inside the wheel, so there are no API keys and no network needed to embed or query. Optional OpenAI / Voyage / Cohere providers exist if you want them; a heavier FastEmbed + Qdrant backend is available via pipx install "docmancer[embeddings-heavy]".

Where your data lives and how to remove it

The local memory index is stored in SQLite-backed files under ~/.docmancer/ (override the main database with DOCMANCER_MEMORY_DB). Sync, query, status, sources, apply, and clear run locally. Provider-backed drafting commands are optional and send selected memory text only after privacy redaction and a provider-use confirmation. You can preview exactly what would be indexed with docmancer memory sync --dry-run, scope the harvest with --include / --exclude globs, and delete the local memory index files with docmancer memory clear. There is no telemetry and no phone-home.

Inspectable. Every section is written to ~/.docmancer/extracted/ as Markdown plus JSON. docmancer inspect shows index stats. docmancer query --explain shows which signal (lexical / dense / sparse) placed each result.

Agent integration built in. docmancer setup drops skill files for Claude Code, Cursor, Codex, Cline, Claude Desktop, Gemini, GitHub Copilot, and OpenCode. For Claude Code and Codex it also injects a memory-recall instruction into the always-loaded CLAUDE.md / ~/.codex/AGENTS.md (a managed block), so the agent reliably calls docmancer memory query before answering questions about past work.

Where to next

The wiki is the authoritative reference for everything else. Pick a page based on what you need:

Page	When to read it
Commands	Core docs commands and Qdrant lifecycle commands
Configuration	All YAML keys, env vars, and the API-key reference
Architecture	How ingest, retrieval, and Qdrant lifecycle work
Supported Sources	What file formats and URL providers are covered
Install Targets	Where each agent's skill file lands
Troubleshooting	Common errors and fixes

Wiki home | Changelog | PyPI