memo

Context7-style docs for your coding agent — free, unlimited, offline, private.

memo is a local MCP server that gives your agent up-to-date library documentation — the same idea as Context7, minus the strings attached: no billing meter, no API key, no rate limit, and your queries never leave your machine.

Why memo?

LLMs hallucinate APIs. They answer from stale training data — and most "docs tools" fix that by sending your queries to someone else's server. memo fixes it on your machine:

Honest caveat: nothing here beats a curated docs provider in coverage. memo ships with 65 pre-built libraries today, and adding one is a one-line PR (see Contributing).

Related MCP server: Hoard

Quickstart (60 seconds)

Requires Python 3.10+ and uv:

# 1) install
uv tool install git+https://github.com/ngabzar02/memo-server

# 2) optional but recommended: download the pre-built index (65 libraries, ~16 MB)
bash tools/fetch-cache.sh

# 3) register the server, then ask your agent about any library

opencode (opencode.json)

{
  "mcp": {
    "memo": {
      "type": "local",
      "command": ["memo"],
      "enabled": true
    }
  }
}

Claude Desktop (claude_desktop_config.json)

{
  "mcpServers": {
    "memo": {
      "command": "memo"
    }
  }
}

Cursor (.cursor/mcp.json)

{
  "mcpServers": {
    "memo": {
      "command": "memo"
    }
  }
}

Make sure the memo binary is on your PATH (uv installs it into ~/.local/bin). First call on a never-indexed library takes ~5–60 s (fetch + index once); every call after that is sub-millisecond.

How it works

One SQLite file, no services, no secrets:

1. resolve_library_id — turns "flask" into candidate library IDs with trust scores: curated aliases → built-in stdlib (py:json, node:fs) → directory.llmstxt.cloud → npm/PyPI (trust = download counts) → GitHub search.

2. get_docs — cache hit is sub-ms; on miss it crawls the docs (llms.txt → sitemap → README), extracts clean text with trafilatura, and chunks it (256 tokens, 50 overlap).

3. Hybrid search — BM25 (SQLite FTS5) always, plus cosine similarity over embeddings (bge-small-en-v1.5 via fastembed/ONNX, stored in sqlite-vec) when vectors exist; normalized score fusion, top hits trimmed to a token budget. On-device the MCP path is FTS-first; full vectors come from the pre-built cache or memo --warmup.

4. versions — version history from npm/PyPI when available.

5. Pre-built cache — a GitHub Actions workflow ingests all 65 libraries on every push and publishes the resulting docs.db (~16 MB) as a release asset. One download, and you're fully offline.

registry → ingest (llms.txt/sitemap/crawl) → SQLite FTS5 + sqlite-vec
        → hybrid BM25+vector fusion → token-budget trim → MCP stdio → your agent

Data lives at ~/.local/share/memo/docs.db. Query it with any SQLite client.

Benchmark

20 real-world queries (frozen in bench/queries.md: 8 Python, 6 Node/TS, 3 web/frontend, 3 Go/other) scored binary hit/miss against Context7's public API:

TBD — the benchmark suite lives in bench/bench.py; results will be published to bench/report.md when it runs.

memo vs Context7 vs mcpdoc

Roadmap

• MCP server: resolve_library_id / get_docs / versions (Context7-compatible API shape)

• Hybrid retrieval: FTS5 BM25 + embeddings, one-file SQLite

• Pre-built cache pipeline (65 libraries, GitHub Actions → release asset)

• Publish bench/report.md — 20-query benchmark vs Context7

• Publish memo to PyPI (currently install via git)

• Self-service: add a library at runtime without a PR

• More libraries every week — the list is cache-libs.txt, one line each

Contributing

One-line library additions, bugs, benchmarks — see CONTRIBUTING.md. Short version: add the library name to cache-libs.txt in a PR; CI builds and ships the new index automatically.

License

MIT — see LICENSE. Use it, fork it, ship it.