Quickstart - https://github.com/jgravelle/jcodemunch-mcp/blob/main/QUICKSTART.md
Use it to make money, and Uncle J. gets a taste. Fair enough? details
| Doc | What it covers |
|---|---|
| QUICKSTART.md | Zero-to-indexed in three steps |
| USER_GUIDE.md | Full tool reference, workflows, and best practices |
| AGENT_HOOKS.md | Agent hooks and prompt policies |
| CONFIGURATION.md | JSONC config file reference, migration from env vars |
| GROQ.md | Groq Remote MCP integration, deployment, gcm CLI |
| ARCHITECTURE.md | Internal design, storage model, and extension points |
| LANGUAGE_SUPPORT.md | Supported languages and parsing details |
| CONTEXT_PROVIDERS.md | dbt, Git, and custom context provider docs |
| TROUBLESHOOTING.md | Common issues and fixes |
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.
In retrieval-heavy workflows, that routinely cuts code-reading token usage by 95%+ because the agent stops brute-reading giant files just to find one useful implementation.
| 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 |
Index once. Query cheaply. Keep moving. Precision context beats brute-force context.
- Artur Skowroński (VirtusLab) — "roughly 80% fewer tokens, or 5× more efficient — index once, query cheaply forever" · GitHub All-Stars #15
- Julian Horsey (Geeky Gadgets) — "3,850 tokens reduced to just 700 — a 5.5× improvement" · JCodeMunch AI Token Saver
- Sion Williams — "preserving tokens for tasks that actually require reasoning rather than retrieval" · March 2026 AI Workflow Update
- Traci Lim (AWS · ASEAN AI Lead) — "structural queries that native tools can't answer: find_importers, get_blast_radius, get_class_hierarchy, find_dead_code" · 5 Repos That Save Token Usage in Claude Code
- Eric Grill — "context is the scarce resource. Cut it by 90% and the whole stack gets cheaper and more reliable" · jCodemunch: Context Engine for AI Agents
jCodeMunch-MCP is free for non-commercial use.
Commercial use requires a paid license.
jCodeMunch-only licenses
- Builder — $79 — 1 developer
- Studio — $349 — up to 5 developers
- Platform — $1,999 — org-wide internal deployment
Want both code and docs retrieval?
Stop paying your model to read the whole damn file.
jCodeMunch turns repo exploration into structured retrieval.
Instead of forcing an agent to open giant files, wade through imports, boilerplate, comments, helpers, and unrelated code, jCodeMunch lets it navigate by what the code is and retrieve only what matters.
That means:
- 95%+ lower code-reading token usage in many retrieval-heavy workflows
- less irrelevant context polluting the prompt
- faster repo exploration
- more accurate code lookup
- less repeated file-scanning nonsense
It indexes your codebase once using tree-sitter, stores structured symbol metadata plus byte offsets into the original source, and retrieves exact implementations on demand instead of re-reading entire files over and over.
Recent releases have made that retrieval workflow sharper and more useful in real engineering work, with BM25-based symbol search, fuzzy matching, semantic/hybrid search (opt-in, zero mandatory dependencies), query-driven token-budgeted context assembly (get_ranked_context), dead code detection (find_dead_code), untested symbol detection (get_untested_symbols), git-diff-to-symbol mapping (get_changed_symbols), architectural centrality ranking (get_symbol_importance, PageRank), blast-radius depth scoring with source snippets, context bundles with token budgets, AST-derived call graphs and call hierarchy traversal, decorator-aware search and filtering, hotspot detection (complexity x churn), dependency cycles and coupling metrics, session-aware routing (plan_turn, turn budgets, negative evidence), agent config auditing, complexity-based model routing (Agent Selector), enforcement hooks (PreToolUse/PostToolUse/PreCompact), dependency graphs, class hierarchy traversal, multi-symbol bundles, live watch-based reindexing, automatic Claude Code worktree discovery (watch-claude), auto-watch on demand (when watch: true in config, the server automatically indexes and watches any repo a tool is called against — ensuring fresh results from the first call), trusted-folder access controls, edit-ready refactoring plans (plan_refactoring) for rename, move, extract, and signature change operations, symbol provenance archaeology (get_symbol_provenance — full git lineage, semantic commit classification, evolution narrative), unified PR risk profiling (get_pr_risk_profile — composite risk score fusing blast radius, complexity, churn, test gaps, and volume), automatic response secret redaction (AWS/GCP/Azure/JWT/GitHub tokens scrubbed before reaching the LLM context window), and cross-language AST pattern matching (search_ast — 10 preset anti-pattern detectors + custom mini-DSL for structural queries like call:*.unwrap, string:/password/i, nesting:5+; works across all 70+ languages with universal node-type mapping).
Measured with tiktoken cl100k_base across three public repos. Workflow: search_symbols (top 5) + get_symbol_source × 3 per query. Baseline: all source files concatenated (minimum cost for an agent that reads everything). Full methodology and harness →
| Repository | Files | Symbols | Baseline tokens | jCodeMunch tokens | Reduction |
|---|---|---|---|---|---|
| expressjs/express | 34 | 117 | 73,838 | ~1,300 avg | 98.4% |
| fastapi/fastapi | 156 | 1,359 | 214,312 | ~15,600 avg | 92.7% |
| gin-gonic/gin | 40 | 805 | 84,892 | ~1,730 avg | 98.0% |
| Grand total (15 task-runs) | 1,865,210 | 92,515 | 95.0% |
Per-query results range from 79.7% (dense FastAPI router query) to 99.8% (sparse context-bind query on Express). The 95% figure is the aggregate. Run python benchmarks/harness/run_benchmark.py to reproduce.
Independent 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:
| Metric | Native | JCodeMunch |
|---|---|---|
| Success rate | 72% | 80% |
| Timeout rate | 40% | 32% |
| Mean cost/iteration | $0.783 | $0.738 |
| Mean cache creation | 104,135 | 93,178 (−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
Most agents still inspect codebases like tourists trapped in an airport gift shop:
- open entire files to find one function
- re-read the same code repeatedly
- consume imports, boilerplate, and unrelated helpers
- burn context window on material they never needed in the first place
jCodeMunch fixes that by giving them a structured way to:
- search symbols by name, kind, or language — with fuzzy matching and optional semantic/hybrid search
- inspect file and repo outlines before pulling source
- retrieve exact symbol implementations only
- grab a token-budgeted context bundle or ranked context pack for a task
- fall back to text search when structure alone is not enough
- detect dead code, trace impact, rank by centrality, and map git diffs to symbols
- plan the next turn with
plan_turn— confidence-guided routing before the first read - track session state and avoid re-reading files the agent already explored
Agents do not need bigger and bigger context windows.
They need better aim.
Find and fetch functions, classes, methods, constants, and more without opening entire files.
Inspect repository structure and file outlines before asking for source.
Send the model the code it needs, not 1,500 lines of collateral damage.
find_importers tells you what imports a file. get_blast_radius tells you what breaks if you change a symbol, with depth-weighted risk scores and optional source snippets. get_class_hierarchy traverses inheritance chains. get_call_hierarchy traces callers and callees N levels deep using AST-derived call graphs, with optional LSP-enriched dispatch resolution for interface/trait method calls. find_dead_code finds symbols and files unreachable from any entry point. get_untested_symbols finds functions with no evidence of test-file reachability — the intersection of import-graph analysis and test-file detection. get_changed_symbols maps a git diff to the exact symbols that were added, modified, or removed. get_symbol_importance ranks your codebase by architectural centrality using PageRank on the import graph. get_hotspots surfaces the riskiest code by combining complexity with git churn. get_dependency_cycles detects circular imports. get_coupling_metrics measures module coupling and instability. get_tectonic_map discovers the logical module topology by fusing three coupling signals (imports, shared references, git co-churn) — revealing hidden module boundaries, misplaced files, and god-module risk without any configuration. get_signal_chains traces how external signals (HTTP requests, CLI commands, scheduled tasks, events) propagate through the codebase via the call graph — discovery mode maps all entry-point-to-leaf pathways and reports orphan symbols, lookup mode tells you which user-facing chains a specific symbol participates in (e.g. "validate_email sits on POST /api/users and cli:import-users"). These are not "faster grep" — they are questions grep cannot answer at all.
audit_agent_config scans your CLAUDE.md, .cursorrules, copilot-instructions.md, and other agent config files for token waste: per-file token cost, stale symbol references (cross-referenced against the index — catches renamed or deleted functions), dead file paths, redundancy between global and project configs, bloat, and scope leaks. No other tool can tell you "line 15 references a function that was renamed three weeks ago."
get_symbol_provenance is git archaeology: given a symbol, it traces every commit that touched it, classifies each into semantic categories (creation, bugfix, refactor, feature, perf, rename, revert), extracts commit intent, and generates a human-readable narrative explaining who created it, why, and how it evolved. get_pr_risk_profile produces a unified risk assessment for a branch or PR — one call fuses blast radius, complexity, churn, test gaps, and change volume into a composite risk score (0.0–1.0) with actionable recommendations. All responses are automatically scanned for leaked credentials (AWS keys, JWTs, GCP service accounts, etc.) and redacted before reaching the LLM.
search_ast brings structural code analysis to every language jCodeMunch indexes — write one query, match across all 70+ languages. Preset anti-patterns detect common problems without any configuration: empty_catch (silently swallowed errors), bare_except (catch-all handlers), deeply_nested (5+ control-flow levels), nested_loops (O(n³)+ performance risk), god_function (100+ line functions), eval_exec (injection-risk dynamic execution), hardcoded_secret (credential patterns in strings), todo_fixme (unfinished work markers), magic_number (unexplained numeric constants), and reassigned_param (overwritten function parameters). Run category='all' for a full sweep, or focus on security, error_handling, complexity, performance, or maintenance. Custom queries use a mini-DSL: call:*.unwrap (find method calls by glob), string:/password/i (regex over string literals), comment:/TODO/i (regex in comments), nesting:5+, loops:3+, lines:80+ (threshold queries). Every match is attributed to its enclosing indexed symbol with complexity metadata — so you can see not just where the problem is, but how bad the surrounding function already is.
Useful for onboarding, debugging, refactoring, impact analysis, and exploring unfamiliar repos without brute-force file reading.
plan_refactoring generates exact edit-ready instructions for rename, move, extract, and
signature change operations. Returns {old_text, new_text} blocks compatible with any editor's
find-and-replace, plus import rewrites, collision detection, new file generation, and multi-file coordination.
Indexes are stored locally for fast repeated access.
jCodeMunch indexes local folders or GitHub repos, parses source with tree-sitter, extracts symbols, and stores structured metadata alongside raw file content in a local index. Each symbol includes enough information to be found cheaply and retrieved precisely later.
That includes metadata like:
- signature
- kind
- qualified name
- one-line summary
- byte offsets into the original file
So when the agent wants a symbol, jCodeMunch can fetch the exact source directly instead of loading and rescanning the full file.
Ubuntu 24.04+ / Debian 12+: System Python is externally managed (PEP 668). Use
pipx install jcodemunch-mcporuv tool install jcodemunch-mcpinstead of barepip install.
pip install jcodemunch-mcp
jcodemunch-mcp initinit 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 (PreToolUse read guard + PostToolUse auto-reindex + PreCompact session snapshot), optionally indexes your project, and audits your agent config files for token waste. Run jcodemunch-mcp init --help for all flags.
For non-interactive CI or scripting:
jcodemunch-mcp init --yes --claude-md global --hooks --index --auditpip install jcodemunch-mcpWant semantic search? Install the local embedding extra for zero-config semantic search — no API keys, no internet after first download:
pip install "jcodemunch-mcp[local-embed]" # bundled ONNX encoder (recommended) jcodemunch-mcp download-model # fetch model (~23 MB, one-time)Want AI-generated summaries? Install the extra for your provider:
pip install "jcodemunch-mcp[anthropic]" # Claude pip install "jcodemunch-mcp[gemini]" # Gemini pip install "jcodemunch-mcp[openai]" # OpenAI-compatible pip install "jcodemunch-mcp[all]" # all providers + local embeddingsWithout an extra, summaries fall back to signatures (which still works — you just get shorter descriptions). Run
jcodemunch-mcp config --checkto verify your provider is installed and working.
If you’re using Claude Code:
claude mcp add jcodemunch uvx jcodemunch-mcpIf you’re using Paperclip (the multi-agent orchestration platform), add a .mcp.json to your workspace root:
{
"mcpServers": {
"jcodemunch": {
"type": "stdio",
"command": "uvx",
"args": ["jcodemunch-mcp"]
},
"jdocmunch": {
"type": "stdio",
"command": "uvx",
"args": ["jdocmunch-mcp"]
}
}
}Paperclip’s Claude Code agents auto-detect .mcp.json at startup. Add both servers to give your agents symbol search + doc navigation without blowing the token budget.
This matters more than people think.
Installing jCodeMunch makes the tools available. It does not guarantee the agent will stop its bad habit of brute-reading files unless you instruct it to prefer symbol search, outlines, and targeted retrieval. The changelog specifically calls out improved onboarding around this because it is a real source of confusion for first-time users.
A simple instruction like this helps:
Use jcodemunch-mcp for code lookup whenever available. Prefer symbol search, outlines, and targeted retrieval over reading full files.Note:
jcodemunch-mcp inithandles steps 2 and 3 automatically. For a comprehensive guide on enforcing these rules through agent hooks and prompt policies, see AGENT_HOOKS.md.
Pre-built indexes for popular frameworks and libraries. Skip the initial indexing step — install a pack and start querying immediately.
# List available packs
jcodemunch-mcp install-pack --list
# Install a free pack
jcodemunch-mcp install-pack fastapi
# Install a licensed pack
jcodemunch-mcp install-pack express --license YOUR-KEYFree packs require no license. Licensed packs require a jCodeMunch license. Use --force to re-download an already-installed pack.
Use jCodeMunch as a remote MCP tool with Groq's ultra-fast inference — answer codebase questions in seconds with zero local setup.
from openai import OpenAI
client = OpenAI(api_key="YOUR_GROQ_KEY", base_url="https://api.groq.com/openai/v1")
response = client.responses.create(
model="llama-3.3-70b-versatile",
input="What does parse_file do in jgravelle/jcodemunch-mcp?",
tools=[{
"type": "mcp",
"server_label": "jcodemunch",
"server_url": "https://YOUR_JCODEMUNCH_URL",
"headers": {"Authorization": "Bearer YOUR_TOKEN"},
"server_description": "Code intelligence via tree-sitter AST parsing.",
"require_approval": "never",
}],
)Groq handles MCP tool discovery and execution server-side — one API call, no orchestration needed.
Self-host with Docker + Caddy for auto-TLS:
DOMAIN=mcp.example.com JCODEMUNCH_HTTP_TOKEN=secret docker compose up -dSee GROQ.md for the full tutorial: allowed-tools presets, model recommendations, deployment options, and validation scripts.
Get a structured PR review in under 5 seconds:
# .github/workflows/speedreview.yml
- uses: jgravelle/jcodemunch-mcp/speedreview@main
with:
groq_api_key: ${{ secrets.GROQ_API_KEY }}See speedreview/README.md for full setup and configuration.
Ask any question about any codebase. Get an answer in under 3 seconds.
pip install jcodemunch-mcp[groq]
export GROQ_API_KEY=gsk_...
# Ask about a GitHub repo (auto-indexes on first use)
gcm "how does authentication work?" --repo pallets/flask
# Ask about the current directory
gcm "where are the API routes defined?"
# Interactive chat mode
gcm --chat --repo facebook/react
# Use the fast 8B model
gcm "what does parse_file do?" --fastCombines jCodeMunch's token-efficient retrieval (BM25 + PageRank) with Groq's 280+ tok/s inference for near-instant answers. See gcm --help for all options.
Speak a question, hear the answer. Full audio loop: Whisper STT → retrieval → LLM → Orpheus TTS.
pip install jcodemunch-mcp[groq-voice]
# Voice conversation with a codebase
gcm --voice --repo pallets/flask
# Press Enter to start recording, Enter again to stop
# Or type a question directly as text fallbackPush-to-talk via Enter key. Caps answers to ~100 words for natural spoken delivery. Requires a microphone.
Generate a narrated explainer video for any codebase in a single command.
pip install jcodemunch-mcp[groq-explain]
# Generate a 60-second narrated explainer
gcm explain --repo pallets/flask -o flask-explainer.mp4
# With verbose timing
gcm explain --repo facebook/react -vPipeline: repo structure → LLM narration script → Orpheus TTS → Pillow slides → FFmpeg MP4. Requires FFmpeg on PATH.
Settings are controlled by a JSONC config file (config.jsonc) with env var fallbacks for backward compatibility. Defaults are chosen so that a fresh install works without any configuration.
jcodemunch-mcp config --init # create ~/.code-index/config.jsonc from template
jcodemunch-mcp config # show effective configuration
jcodemunch-mcp config --check # validate config + verify prerequisites--check validates that your config file is well-formed, your AI provider package is installed, your index storage path is writable, and HTTP transport packages are present. Exits non-zero on any failure — useful for CI/CD or first-run scripts.
| Layer | Path | Purpose |
|---|---|---|
| Global | ~/.code-index/config.jsonc |
Server-wide defaults |
| Project | {project_root}/.jcodemunch.jsonc |
Per-project overrides |
Project config merges over global config — closest to the work wins.
| Config key | What it controls | Typical savings |
|---|---|---|
tool_profile |
"core" (16 tools), "standard" (~40), "full" (all, default) |
~5-6k tokens (core) |
compact_schemas |
Strip rarely-used advanced params from schemas | ~1-2k tokens |
disabled_tools |
Remove individual tools from schema entirely | ~100–400 tokens/tool |
languages |
Shrink language enum + gate features | ~2–86 tokens/turn |
meta_fields |
Filter _meta response fields |
~50–150 tokens/call |
descriptions |
Control description verbosity | ~0–600 tokens/turn |
Recommended for context-conscious setups: "tool_profile": "core", "compact_schemas": true reduces the schema footprint from ~11.5k tokens to ~4k tokens.
See the full template for all available keys. Run jcodemunch-mcp config --init to generate one.
Place a .jcodemunch.jsonc file at your project root to declare the layers your architecture must respect. get_layer_violations will then enforce that imports only flow in the declared direction.
Call get_layer_violations(rules=[...]) directly to pass rules inline — the config file is optional and used as a fallback. When no config is present, get_layer_violations infers layers from top-level directory structure.
The following env vars still work but are deprecated. Config file values take priority:
| Variable | Config key | Default |
|---|---|---|
JCODEMUNCH_USE_AI_SUMMARIES |
use_ai_summaries |
true |
JCODEMUNCH_TRUSTED_FOLDERS |
trusted_folders |
[] |
JCODEMUNCH_MAX_FOLDER_FILES |
max_folder_files |
2000 |
JCODEMUNCH_MAX_INDEX_FILES |
max_index_files |
10000 |
JCODEMUNCH_STALENESS_DAYS |
staleness_days |
7 |
JCODEMUNCH_MAX_RESULTS |
max_results |
500 |
JCODEMUNCH_EXTRA_IGNORE_PATTERNS |
extra_ignore_patterns |
[] |
JCODEMUNCH_CONTEXT_PROVIDERS |
context_providers |
true |
JCODEMUNCH_REDACT_SOURCE_ROOT |
redact_source_root |
false |
JCODEMUNCH_STATS_FILE_INTERVAL |
stats_file_interval |
3 |
JCODEMUNCH_SHARE_SAVINGS |
share_savings |
true |
JCODEMUNCH_SUMMARIZER_CONCURRENCY |
summarizer_concurrency |
4 |
JCODEMUNCH_ALLOW_REMOTE_SUMMARIZER |
allow_remote_summarizer |
false |
JCODEMUNCH_RATE_LIMIT |
rate_limit |
0 |
JCODEMUNCH_TRANSPORT |
transport |
stdio |
JCODEMUNCH_HOST |
host |
127.0.0.1 |
JCODEMUNCH_PORT |
port |
8901 |
JCODEMUNCH_LOG_LEVEL |
log_level |
WARNING |
AI provider keys (ANTHROPIC_API_KEY, GOOGLE_API_KEY, OPENAI_API_BASE, MINIMAX_API_KEY, ZHIPUAI_API_KEY, etc.), JCODEMUNCH_SUMMARIZER_PROVIDER, and CODE_INDEX_PATH are always read from env vars — they are never placed in config files.
AI provider priority in auto-detect mode: Anthropic → Gemini → OpenAI-compatible (OPENAI_API_BASE) → MiniMax → GLM-5 → signature fallback. Set JCODEMUNCH_SUMMARIZER_PROVIDER to force anthropic, gemini, openai, minimax, glm, or none. jcodemunch-mcp config shows which provider is active.
allow_remote_summarizer only affects OpenAI-compatible HTTP endpoints. When false, jcodemunch accepts only localhost-style endpoints such as Ollama or LM Studio on 127.0.0.1 and rejects remote hosts like api.minimax.io. When a remote endpoint is rejected, AI summarization falls back to docstrings or signatures instead of sending source code to that provider. Set allow_remote_summarizer: true in config.jsonc if you intentionally want to use a hosted OpenAI-compatible provider such as MiniMax or GLM-5.
A common question: does this only help during exploration, or also when the agent is prompted to read a file before editing?
It helps most when editing a specific function. The "read before edit" constraint doesn't require reading the whole file — it requires reading the code. get_symbol_source gives you exactly the function body you're about to touch, nothing else. Instead of reading 700 lines to edit one method, you read those 30 lines.
| 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 |
The cases where it doesn't help: edits that genuinely require understanding the entire file (restructuring file-level state, reordering logic that spans hundreds of lines). For those, get_file_content is roughly equivalent to Read. The cases where it helps most are targeted edits — one function, one method, one class — which is the majority of real editing work.
- large repositories
- unfamiliar codebases
- agent-driven code exploration
- refactoring and impact analysis
- teams trying to cut AI token costs without making agents dumber
- developers who are tired of paying premium rates for glorified file scrolling
Start with QUICKSTART.md for the fastest setup path.
Then index a repo, ask your agent what it has indexed, and have it retrieve code by symbol instead of reading entire files. That is where the savings start.
jCodeMunch plugs into any MCP-compatible agent or IDE. Tested configurations:
| Platform | Config |
|---|---|
| Claude Code / Claude Desktop | jcodemunch-mcp init (auto-detects and patches config) |
| Cursor / Windsurf | jcodemunch-mcp init or manual mcp.json |
| Hermes Agent | Add to ~/.hermes/config.yaml — see skill |
| Any MCP client | stdio: jcodemunch-mcp, HTTP: jcodemunch-mcp serve --transport sse |
Hermes Agent config
# ~/.hermes/config.yaml
mcp_servers:
jcodemunch:
command: "uvx"
args: ["jcodemunch-mcp"]