New frontier models.
Same token bloat.
jCodeMunch cuts it 95%+

Short version: RepoMapper is a ranked repository "map" (great for orientation and "what matters?"), while jCodeMunch is symbol-accurate retrieval (great for "show me the exact code" with tiny token spend). They overlap, but they're optimized for different jobs.

• RepoMapper generates a "repo map" that highlights important files/definitions and relationships using Tree-sitter parsing plus a PageRank-like importance ranking. Best for first-pass orientation: "Which files matter for this task?"
• jCodeMunch is symbol-first, not file-first: agents search and retrieve functions/classes/methods/constants directly via byte-offset seeking in O(1) time. File reads become the exception, not the default.
• Scaling: maps get bigger as repos grow; targeted symbol pulls stay tiny even in massive repos.

jCodeMunch works with any client that supports the Model Context Protocol (MCP), including:

• Claude Code — Anthropic's CLI for Claude, with native MCP support
• Google Antigravity — Google's AI coding agent
• Cursor — AI-native code editor
• Gemini — Google's AI assistant with MCP integration
• Any other MCP-compatible client or custom integration

Antigravity uses a standard MCP config file — setup takes about a minute.

• Install the server: pip install git+https://github.com/jgravelle/jcodemunch-mcp.git
• In Antigravity, open the Agent pane → click the ⋮ menu → MCP Servers → Manage MCP Servers
• Click View raw config to open mcp_config.json
• Add the entry below, save, then restart the MCP server from the Manage MCPs pane

{
  "mcpServers": {
    "jcodemunch": {
      "command": "jcodemunch-mcp",
      "env": {
        "GITHUB_TOKEN": "ghp_...",
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

Larger context windows have diminishing returns for code retrieval:

• Cost scales linearly: reading 214K tokens costs ~$1.08 per query regardless of window size. jCodeMunch retrieves the same answer for ~$0.0024.
• Signal-to-noise ratio drops: dumping entire files into context means the AI wades through thousands of irrelevant lines to find the one function it needs. Larger windows amplify the noise problem, they don't solve it.
• Latency grows: more input tokens = slower time-to-first-token. Symbol retrieval returns results in milliseconds.
• Attention degrades: research shows LLMs struggle with retrieval accuracy as context length increases — the "lost in the middle" effect. Smaller, precise context performs better.

Absolutely — they're designed as complementary tools. A typical pairing:

• jCodeMunch for code retrieval: functions, classes, constants, methods — any symbol in your codebase.
• jDocMunch for documentation retrieval: README sections, API docs, specs, architecture guides.

Together, they give AI agents surgical access to both code and docs without reading entire files. When an agent needs to understand how authentication works, it can search code symbols for the implementation and search doc sections for the design rationale — all with minimal token spend.

In benchmarks measured with tiktoken cl100k_base across 15 tasks on 3 real repositories, jCodeMunch achieved a 95% average token reduction for code retrieval operations.

• fastapi/fastapi benchmark: 214,312 tokens (reading all files) → ~480 tokens (symbol retrieval) = 99.8% reduction
• Results vary by query type — retrieval of a single function body is near-zero cost, while broader searches return more symbols but still far less than full file reads.
• The 95% average is a conservative, tokenizer-measured figure across diverse query types and repos of different sizes.