Skip to main content
Glama
jCodeMunch
by adefemi-dev

jCodeMunch MCP

The most token-efficient MCP server for precise source code retrieval via tree-sitter AST parsing. Cut AI token costs 86-99% on code exploration (96% average, benchmarked at 27.9x fewer tokens than a grep-and-read agent) and stop burning your context window reading entire files.

Real results, live from production 838B+ tokens saved · 136,000+ reporting installs · $4.2M+ in AI spend avoided · 100,000+ kg CO₂ prevented Counter figures as of 2026-08-17, valued at the $5/MTok Claude Opus input rate. All four only grow, so read them as floors. Live at jcodemunch.com.

Works with Claude Code, Cursor, VS Code, Codex CLI, Windsurf, Continue, and any MCP-compatible client.

Install now · Quickstart · See the evidence · Pricing

PyPI version PyPI - Python Version License MCP Local-first Issues closed DOI

Free for personal use. Use it to make money, and Uncle J. gets a taste. Fair enough? Commercial licenses below. Our guarantee: if jCodeMunch doesn't pay for itself, you don't pay for jCodeMunch.


Why jCodeMunch?

Most AI agents explore repositories the expensive way: open entire files, skim thousands of irrelevant lines, repeat. That is not "a little inefficient." That is a token incinerator.

jCodeMunch indexes a codebase once and lets agents retrieve only the exact code they need: functions, classes, methods, constants, outlines, and tightly scoped context bundles, with byte-level precision. It parses source with tree-sitter, stores structured symbol metadata (signature, kind, qualified name, summary, byte offsets) alongside raw file content in a local index, and fetches exact implementations on demand instead of re-reading files over and over.

Task

Traditional approach

With jCodeMunch

Find a function

Open and scan large files

Search symbol, fetch exact implementation

Understand a module

Read broad file regions

Pull only relevant symbols and imports

Explore repo structure

Traverse file after file

Query outlines, trees, and targeted bundles

"What breaks if I change X?"

Not possible

get_blast_radius

Index once. Query cheaply. Keep moving. Precision context beats brute-force context.


Related MCP server: Symbol Delta Ledger

Evidence

Reproducible token efficiency benchmark

Measured with tiktoken cl100k_base across three public repos pinned to upstream commits, run 2026-08-03 on v1.108.233. Workflow: search_symbols (top 5) + get_symbol_source × 3 per query. Two baselines, same run, same corpus, same file reader:

  • Grep-top-3: rg -l the query terms, rank files by match count, open the top 3 whole. This is what a competent agent without the tool actually does, and it is the number to quote.

  • Read-all: every indexed source file concatenated. A ceiling nobody pays; retained for continuity with previously published figures.

Repository

Files

Symbols

Grep-top-3 baseline

jCodeMunch

vs grep

vs read-all

expressjs/express

182

200

15,724 avg

1,007 avg

15.6x

153.2x

fastapi/fastapi

1,182

6,841

85,296 avg

2,209 avg

38.6x

372.9x

gin-gonic/gin

98

1,179

31,975 avg

1,545 avg

20.7x

98.3x

Grand total (15 task-runs)

664,975

23,805

27.9x

237.3x

Against a grep-and-read agent: 96.4% reduction, 27.9x fewer tokens. Per-query results range from 7.3x to 84.3x (median 25.5x); no single multiple describes every query. Against read-all the figure is 99.6%, but nobody pays that ceiling. Compact MUNCH wire encoding then trims a median 45.5% more bytes off responses.

Full methodology, pinned commits, harness, and known caveats: benchmarks/METHODOLOGY.md · Reproduce it yourself · TOKEN_SAVINGS.md

Independent A/B test on a production codebase

50-iteration A/B test on a real Vue 3 + Firebase production codebase, jCodeMunch vs native tools (Grep/Glob/Read), Claude Sonnet 4.6, fresh session per iteration: success rate 80% vs 72%, timeout rate 32% vs 40%, mean cache creation down 10.5%. Tool-layer savings isolated from fixed overhead: 15-25%. One finding category appeared exclusively in the jCodeMunch variant: orphaned file detection via find_importers, a structural query native tools cannot answer without scripting. Full report: benchmarks/ab-test-naming-audit-2026-03-18.md

Mentioned by

Full recognition page →


Install

One-click installs

Install in VS Code Install in VS Code Insiders Install in Cursor

uv tool install jcodemunch-mcp
jcodemunch-mcp init

No virtualenv to manage, nothing written into system Python, and it works as-is on PEP 668 distros (Ubuntu 24.04+, Debian 12+) where bare pip install is refused. Don't have uv yet?

init auto-detects your MCP clients (Claude Code, Claude Desktop, Cursor, Windsurf, Continue), writes their config entries, installs the CLAUDE.md prompt policy so your agent actually uses jCodeMunch, optionally installs enforcement hooks, optionally indexes your project, and audits your agent config files for token waste.

Command

Use it when

uvx jcodemunch-mcp

Zero install. Runs from an ephemeral environment — nothing lands on disk permanently. The client entries init writes already invoke the server this way, so for most setups this is all that ever runs. ⚠ Enforcement hooks are the exception: they're spawned by a minimal-PATH subshell and resolve the executable by name, so they need uv tool install (or pipx/pip) to work.

pipx install jcodemunch-mcp

You already standardise on pipx

pip install jcodemunch-mcp

Inside a virtualenv you manage yourself

Verify:

jcodemunch-mcp --version

Manual Claude Code setup

claude mcp add -s user jcodemunch -- uvx jcodemunch-mcp

No install step — uvx fetches and runs the server on demand. Prefer it on your PATH (and required for enforcement hooks)? uv tool install jcodemunch-mcp, then claude mcp add -s user jcodemunch jcodemunch-mcp.

Then tell the agent to prefer the tools. This matters more than people think; installation makes the tools available but does not break the agent's brute-reading habit. One line in your CLAUDE.md does it:

Call the jcodemunch_guide tool and strictly follow its instructions.

Using Cursor, Windsurf, Codex CLI, Antigravity, Gemini CLI, Qwen Code, Kiro, Cline, Zed, Goose, Hermes, Odysseus, or Paperclip? Every tested client configuration lives in CLIENTS.md. Optional extras (local semantic search, AI summaries per provider) are in QUICKSTART.md; the system surfaces each extra pulls in are documented in SECURITY.md.


Quickstart

Full walkthrough: QUICKSTART.md. The two-minute version, inside your agent after init:

  1. Ask: "Index this repo with jcodemunch."

  2. Ask: "Using jcodemunch, find the function that handles authentication and show me its source."

The agent should answer via search_symbols and get_symbol_source, returning tens of lines instead of whole files. Confirm with get_session_stats: it reports tokens served and savings for the session. That is where the numbers on the meter come from.

Want to skip initial indexing for popular frameworks? Pre-built starter packs: jcodemunch-mcp install-pack --list (free packs need no license).


What you can do

  • Retrieve one symbol instead of loading a file. get_symbol_source returns the exact function body, byte-precise, for the majority of edits that touch one function in a 700-line file (~95% savings on that read).

  • Assemble a whole task's context in one call. assemble_task_context classifies the task intent, extracts anchor symbols, and runs the right tool sequence under one token budget. plan_turn routes the turn before the first read.

  • Ask structural questions grep can't answer. find_importers, get_blast_radius, get_call_hierarchy, find_dead_code, get_changed_symbols, get_hotspots, search_ast anti-pattern sweeps, and more.

  • Preflight risky changes, and know when to stop. check_edit_safe, check_delete_safe, get_pr_risk_profile, and plan_refactoring with edit-ready {old_text, new_text} blocks. The two safety checks return stop_rule.terminal: true means no further jcodemunch call moves the verdict, so re-running find_importers or check_references to be sure is wasted work. It means final, not safe. False names the specific thing that would change the answer.

  • Trust the answers. Calibrated confidence scores, freshness flags, coverage contracts on absence claims, compiler-verified references via SCIP import, and automatic secret redaction before anything reaches the LLM.

  • Keep the index fresh automatically. Watch modes, agent hooks, and a VS Code extension close the staleness gap.

That's the highlight reel. The complete tour of 90+ tools, the MUNCH compact wire format, evidence receipts, offloadable-work annotation, and the session-economics instrumentation is in CAPABILITIES.md, with internals in UNDER_THE_HOOD.md.

What's new

  • v1.108.293 (2026-08-23) — Ten skipped modules that hid 209 tests

  • v1.108.292 (2026-08-23) — The one string that survives tool deferral

  • v1.108.291 (2026-08-22) — Counting each byte of source once


When does it help (and when doesn't it)?

Scenario

Native tool

jCodeMunch

Savings

Edit one function (700-line file)

Read → 700 lines

get_symbol_source → 30 lines

~95%

Understand a file's structure

Read → full content

get_file_outline → names + signatures

~80%

Find which file to edit

Grep many files

search_symbols → exact match

comparable

Edit requires whole-file context

Read → full content

get_file_content → full content

~0%

"What breaks if I change X?"

not possible

get_blast_radius

unique capability

It helps most on targeted edits (one function, one method, one class), which is the majority of real editing work. Edits that genuinely require the entire file (restructuring file-level state, reordering logic spanning hundreds of lines) see no advantage. Best fits: large repositories, unfamiliar codebases, agent-driven exploration, refactoring and impact analysis, and teams cutting AI token costs without making agents dumber.

Languages: 70+ via tree-sitter, including Python, JavaScript/TypeScript, Go, Rust, Java, C/C++, C#, PHP, Ruby, Swift, and Kotlin. Full matrix: LANGUAGE_SUPPORT.md. Monorepos: yes; incremental indexing, workspace-member detection, subpath scoping.


Security, privacy, and background behavior

Local-first by design: indexes live at ~/.code-index/, and the base package's only default network behavior is an anonymous savings counter (random ID plus aggregate token counts, no code, no paths, no PII; opt out with share_savings: false). Everything the server does beyond answering a tool call (file watching, the opt-in login service, license validation, model downloads, org reporting) is opt-in or opt-out, visible, and reversible, and every item is enumerated in SECURITY.md alongside the path-traversal, symlink, and secret-redaction controls.


Documentation

Doc

What it covers

QUICKSTART.md

Zero-to-indexed in three steps

CLIENTS.md

Tested configuration for every MCP client

USER_GUIDE.md

Full tool reference, workflows, and best practices

CAPABILITIES.md

The complete capability reference beyond the highlight reel

CONFIGURATION.md

Config file reference, token-control levers, tool tiering, the Counter

UNDER_THE_HOOD.md

The technical manual: verdicts, ranking internals, provenance contracts

ARCHITECTURE.md

Internal design, storage model, and extension points

GROQ.md

Groq Remote MCP, the gcm CLI, speedreview GitHub Action

HEADLESS.md

Using jCodeMunch with claude -p

AGENT_HOOKS.md

Agent hooks and prompt policies

LANGUAGE_SUPPORT.md

Supported languages and parsing details

SECURITY.md

Security controls, data movement, background behavior

TROUBLESHOOTING.md

Common issues and fixes

CHANGELOG.md · ROADMAP.md

Release history and what's next


Licensing and commercial use

jCodeMunch-MCP is released under the jCodeMunch-MCP Dual-Use License (full terms). Free for non-commercial use. Commercial use requires a paid license, one-time, sold by jMunch LLC via Stripe:

jCodeMunch-only: Builder, $79 (1 developer) · Studio, $349 (up to 5) · Platform, $1,999 (org-wide internal deployment)

Full jMunch suite (code + docs + data): Trio Builder, $99 · Trio Studio, $449 · Trio Platform, $2,499

Not sure it's worth it? Run your own numbers through the ROI calculator, or forward the finance-team version to whoever signs off. The guarantee stands: if jCodeMunch doesn't pay for itself, you don't pay for jCodeMunch.

Conditions on all uses: retain the copyright notice, clearly mark modifications and keep the original author's name intact (he's kinda full of himself), and include a prominent modification notice in source redistributions. The Software may not be renamed, rebranded, or published to any public package registry, and is provided "AS IS" without warranty. LICENSE controls.


FAQ

How much can I save on Claude / Opus tokens? In retrieval-heavy workflows, code-reading tokens typically drop 86-99%, benchmarked at 96.4% average (27.9x) against a grep-and-read agent across 15 tasks and 3 repositories. Per-query results span 7.3x to 84.3x. Methodology: TOKEN_SAVINGS.md and benchmarks/.

How is this different from RAG or grep-based tools? jCodeMunch retrieves at the symbol level with byte-level precision (functions, classes, importers, blast radius, hierarchies) rather than fuzzy chunks (RAG) or raw line matches (grep) the agent still has to read and reason over.

Is it free for personal use? Yes. Commercial use needs a license; see above.

Where's the deep-dive on X? Capabilities: CAPABILITIES.md. Config: CONFIGURATION.md. Clients: CLIENTS.md. Internals: UNDER_THE_HOOD.md. Or the firehose: jcodemunch.com.


Extras: OSS code-health observatory (weekly six-axis snapshots of Express, FastAPI, Gin, Django, and friends) · Token Cost Radar (daily AI token cost intelligence) · jMunch Console (free MIT GUI for one-click upgrades)

Available Tools

6 tools
announce_modelA

Agent self-reports its active model identifier. Server resolves to a tier via model_tier_map (fuzzy: normalize → exact → glob → substring → '*' → 'full') and narrows the exposed tool list accordingly. Idempotent: a second call with the same model is a cheap no-op. Prefer calling plan_turn(model=...) for routine per-task use; use announce_model as a fallback when plan_turn is not appropriate for the current task.

Inputs: model (required).

jcodemunch_guideA
Read-only

Return the version-current CLAUDE.md / AGENT.md policy snippet for jcodemunch-mcp — the same text produced by jcodemunch-mcp claude-md --generate. Lets an agent keep a one-line CLAUDE.md (e.g. "Call jcodemunch_guide and strictly follow its instructions.") instead of pasting a static snippet that drifts from the installed version. Idempotent, no repo context required. Matches the active tool surface, tier and disabled_tools — list 'jcodemunch_guide' in disabled_tools to hide it.

Inputs: no named parameters.

orderA

Dispatch any jcodemunch action by name: order(action, args). The single-verb front door to the full tool catalog. Read-only by default — actions that change index/session state require allow_state_change=true, and execution/file-write verbs are refused. For exploration questions ('how does X work'), order('get_ranked_context', {repo, query, token_budget}) answers in ONE call — prefer it over chained search/outline/source hops; add compress=true to fit more symbols in the same budget. Call 'menu' to discover actions, or 'route' to pick one from a task.

Inputs: action (required), args, allow_state_change.

routeA

Map a natural-language task to the best catalog action(s): route(task, repo?, execute?). Returns ranked recommendations with ready-to-run argument templates. With execute=true, dispatches the top recommendation and returns its result in the same call, collapsing discover-then-call into one round-trip. Recommends assemble_task_context / plan_turn for context-gathering intents.

Inputs: task (required), repo, model, execute.

set_tool_tierA

Explicit tier override for the current session. Narrows or widens the exposed tool list to 'core' / 'standard' / 'full'. Prefer plan_turn(model=...) for routine per-task use; use set_tool_tier only when you need an explicit override (e.g. escalate mid-task to 'full' after a capability-gated failure).

Inputs: tier (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 6 tools

    Disambiguation4/5

    Tools are mostly distinct: tier management (set_tool_tier vs announce_model), discovery (menu vs route), dispatch (order), and policy (jcodemunch_guide) each have clear purposes. However, menu and route both aid in discovering actions, and set_tool_tier/announce_model both influence tier, so a small overlap exists but descriptions clarify boundaries.

    Naming Consistency2/5

    Naming is inconsistent: set_tool_tier and announce_model follow a verb_noun pattern, but menu, order, and route are single words, and jcodemunch_guide is a noun phrase. There is no uniform convention across the set, which makes the API slightly harder to predict.

    Tool Count5/5

    Six tools is well within the ideal range for a server focused on agent self-management and action dispatch. Each tool has a clear role, and the count feels neither thin nor bloated.

    Completeness4/5

    The surface covers the core lifecycle: tier control (set_tool_tier, announce_model), discovery (menu, route), dispatch (order), and policy guidance (jcodemunch_guide). Potential gaps like a direct 'get current tier' tool are minor and workaroundable via announce_model, so the set is largely complete for its stated purpose.

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      B
      maintenance
      Enables LLMs to efficiently read, write, and refactor code using precise AST-based operations, reducing token usage and context window waste.
      25
      238 npm
      3
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Provides structured, token-efficient code context for AI assistants by indexing codebases with AST-level analysis, supporting 17+ languages, enabling semantic search, call-site tracking, and PR attribution.
      45 PyPI
      42
      MIT