SigMap vs alternatives
SigMap solves the same problem as embeddings, RAG, and compressed context tools — but from a different angle. This page is a direct comparison.
How to read the tables about other tools
A column headed characterized is read from that tool's own README, at the commit linked in the header, on the date shown. Nothing was installed or run, and any figure in it is the tool's own claim about its own benchmark, not something measured here. A measured head-to-head on the same repositories is tracked in #972; when it lands, a column is re-headed measured, with the suite and date. SigMap's own figures are derived from version.json and the saved benchmark reports, and a test pins the tool counts below to them.
SigMap vs embeddings / RAG
Embedding-based retrieval is the default mental model most developers reach for. SigMap takes the opposite approach.
| SigMap | Embeddings / RAG | |
|---|---|---|
| Dependencies | Zero | Vector DB, embedding model, infra |
| Setup time | 30 seconds | Hours to days |
| Latency per query | < 100 ms | 200 ms–2 s+ (network + model) |
| Determinism | Always same result | Varies with model drift and index staleness |
| Offline / air-gapped | Yes | Rarely |
| Cost per query | Free | $0.01–$0.10+ |
| Explainability | Ranked signature list | Black-box similarity score |
| Maintenance | None | Index rebuild on every schema change |
Right-hand column: typical figures for the category, not measurements of a named product.
SigMap ranks extracted function signatures with BM25 — no vectors, no infra, no drift. The tradeoff is that it only works well with code (which is the use case).
When to use embeddings instead
If your retrieval target is free-form documentation, markdown, or natural-language artifacts rather than source code signatures, embeddings may be a better fit. SigMap is optimized for code.
SigMap vs RepoMix
RepoMix packs a repository into one AI-friendly file. SigMap extracts signatures and ranks them for a question. They overlap on compression and on MCP, and differ on what comes out.
| SigMap | RepoMix (characterized: README, 2026-10-18) | |
|---|---|---|
| What it produces | A ranked signature map, per query | One packed file of the repository (or the files its include and ignore patterns select) |
| Token reduction | 95.2% average (the map against every source file, 21 repos) | ~70% with --compress, which uses Tree-sitter to keep signatures (its README's figure) |
| Retrieval accuracy (hit@5) | 80.4% on the retrieval corpus; 56.7% on repositories we do not control | No retrieval metric in its README |
| Query-aware context | Yes — ranked per query | Not described: it packs. Its MCP server can search a packed file (grep_repomix_output) |
| Dependency graph | Yes — import-aware BFS | Not described in its README |
| Learn from usage | Yes — sigmap learn | Not described in its README |
| Validate coverage | Yes — sigmap validate | Not described in its README |
| Judge answer groundedness | Yes — sigmap judge | Not described in its README |
| Works with MCP tools | Yes — 22 by default; 7 with mcp.tools: core | Yes — repomix --mcp: 5 tools, 7 with --sandbox |
Both token figures are size ratios against the uncompressed source, not a cost per question, and they were not measured on the same repositories. The practical difference: what RepoMix packs does not depend on what you ask, and SigMap's output is ranked for the specific query.
SigMap vs codebase-memory-mcp
codebase-memory-mcp indexes a codebase into a persistent knowledge graph and serves it to coding agents over MCP. It overlaps SigMap's graph and impact features, and by its own README it is ahead of SigMap on language count and type resolution.
| SigMap | codebase-memory-mcp (characterized: README, 2026-10-22) | |
|---|---|---|
| What it is | A signature map, a ranker and a verifier, written as files and served by an optional MCP server | A local MCP server over a persistent code knowledge graph (functions, classes, imports, calls) |
| Index and ranking | Extracted signatures with line anchors, ranked with BM25; no embeddings, no database | SQLite, with BM25 full-text search (FTS5) and vector search using bundled nomic-embed-code embeddings |
| Languages | 38 | 162 (its badge), with hybrid LSP type resolution |
| MCP tools | 22 by default; 7 with mcp.tools: core | 17 |
| Install | npx sigmap, zero dependencies | A native executable from an install script (macOS, Linux, Windows) |
| Verifies AI output against the code | Yes — sigmap verify, sigmap judge | Not described in its README |
| Its headline claim | — | A preprint over 31 repositories reports 10× lower token use and 2.1× fewer tool calls than file-by-file exploration (March 2026 measurements); its earlier five-query comparison (~3,400 against ~412,000 tokens, "about 120× fewer") is now described as earlier |
| Measured head to head | Not yet — #972 | Not yet |
SigMap vs code-review-graph
code-review-graph builds a graph of the code with Tree-sitter and serves review-sized context over MCP, so an assistant reads the files a change touches.
| SigMap | code-review-graph (characterized: README, 2026-10-18) | |
|---|---|---|
| What it is | A signature map, a ranker and a verifier | A local code knowledge graph for review context over MCP and a CLI |
| Index and ranking | Extracted signatures, ranked with BM25; no embeddings, no database | Tree-sitter ASTs (with fallbacks) in one SQLite file; optional vector embeddings |
| Languages | 38 | Tree-sitter where a grammar exists, targeted fallbacks elsewhere, and custom languages through a languages.toml |
| MCP tools | 22 by default; 7 with mcp.tools: core | 30 |
| Install | npx sigmap, zero dependencies | pip install code-review-graph, Python 3.10 or later |
| Verifies AI output against the code | Yes — sigmap verify, sigmap judge | Not described in its README |
| Its headline claim | — | ~63× median per-question token reduction (range 35× to 358×) over 6 repositories, whole-corpus against graph query. Its README adds that the whole-corpus baseline is "an upper bound no real agent pays" |
| Measured head to head | Not yet — #972 | Not yet |
SigMap vs Headroom
Headroom is a different kind of tool: it compresses what an agent reads (tool outputs, logs, RAG chunks, files, conversation history) on its way to the model. Its README describes compressing what flows to the model, not indexing your codebase, so the two act on different inputs.
| SigMap | Headroom (characterized: README, 2026-10-18) | |
|---|---|---|
| What it is | A map of the codebase, ranked for a question | A compression layer for tool outputs, logs, RAG chunks, files and history, as a library, a proxy or an agent wrapper |
| Approach | Deterministic signature extraction; no model in the core | Content-type compressors, including a trained text model (Kompress-v2-base) behind an optional extra |
| MCP tools | 22 by default; 7 with mcp.tools: core | 3 (headroom_compress, headroom_retrieve, headroom_stats) |
| Install | npx sigmap, zero dependencies | pip install "headroom-ai[all]", or npm install headroom-ai for the TypeScript SDK |
| Its headline claim | — | 21% to 57% fewer tokens across four scenarios built from MCP server output formats (code search 21%, codebase exploration 42%, issue triage 30%, incident debugging 57%) |
| Measured head to head | Not applicable — they act on different inputs | Not applicable |
SigMap vs Copilot / IDE context window
Copilot and other AI IDEs send everything they can see in the open editors. SigMap sends only what the current query needs.
| SigMap | IDE context (Copilot, etc.) | |
|---|---|---|
| Selection strategy | Query-ranked signatures | Recent open files |
| Token cost per session | ~200–4,000 tokens | ~8,000–80,000 tokens |
| Works across all editors | Yes | IDE-specific |
| Validates coverage | Yes | No |
| Judges answer groundedness | Yes | No |
| Reproducible | Yes | No — depends on open files |
| MCP-native | Yes — 22 by default; 7 with mcp.tools: core | Partial |
Right-hand column: typical figures for the category, not measurements of a named product.
Copilot and SigMap are complementary: Copilot sends the live editor context, SigMap sends the ranked codebase map. Many teams use both.
SigMap vs manual context curation
Some teams maintain a hand-written AGENTS.md or instructions file. SigMap generates and keeps it current automatically.
| SigMap | Hand-written instructions | |
|---|---|---|
| Keeps up with code changes | Yes — regenerates on every commit | Manual update required |
| Structured by module | Yes — per-module signature blocks | Usually flat text |
| Benchmark-tested accuracy | 80.4% hit@5 (retrieval corpus); 2.37× vs grep on the honest corpus (92.8% vs 39.2%) | Not measured |
| Time to set up | 30 seconds | Hours |
Right-hand column: typical figures for the category, not measurements of a named product.
What SigMap does not replace
- Full-text search — SigMap extracts signatures, not full source. If you need to search comment text or string literals,
grepis still the right tool. - LSP / go-to-definition — SigMap is a context layer, not a language server. It does not provide hover types or jump-to-definition.
- Security scanning — SigMap redacts secrets from context output but is not a SAST tool.
Summary
| Need | Best fit |
|---|---|
| Fast, accurate, zero-infra code context | SigMap |
| Searching prose / documentation | Embeddings |
| Compressing code for LLM input (no query) | RepoMix |
| A persistent knowledge graph with type resolution across many languages | codebase-memory-mcp |
| Graph-based review context for a change, over MCP | code-review-graph |
| Compressing tool outputs, logs and history in flight | Headroom |
| IDE-integrated inline suggestions | Copilot / IDE plugin |
| Deep semantic search across heterogeneous content | RAG pipeline |