mcp-injector

by foldwork-dev

359 downloads

Not rated

GitHub Website

About

Compresses codebases with AST body folding before sending to Claude Code, Cursor, or VS Code — 57-89% token reduction with deterministic output for KV cache hits.

Details

Author: foldwork-dev
Downloads: 359
Categories: Developer Tools, AI

- 41-89% token reduction — verified across Django (Python), Tokio (Rust), Gin (Go), and more
- AST body folding — compresses function bodies into placeholders; Claude only reads what it needs
- BM25 full-text search — fast symbol and code search without reading raw files
- Zero config — single Go binary, works immediately after install
- Offline-first — runs entirely locally, no network calls, no telemetry
- Free tier — unlimited for codebases under 100K lines

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below
Plugin Name mcp-injector

Command (node, npx, python, etc.) /home/$USER/.local/bin/mcp-injector
Environment
- MCP_WORKSPACE /path/to/your/project
Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

From the repository

```sh
curl -fsSL https://foldwork.dev/install.sh | sh

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "mcp-injector": {
            "command": "/home/$USER/.local/bin/mcp-injector",
            "env": {
                "MCP_WORKSPACE": "/path/to/your/project"
            }
        }
    }
}

Command

"/home/$USER/.local/bin/mcp-injector"

Env

{
    "MCP_WORKSPACE": "/path/to/your/project"
}

AI coding assistants often fail because they retrieve the wrong context. On a large codebase, blindly dumping raw files into the prompt leads to hallucinations, slow responses, and high API costs.

Foldwork fixes this. It is a deterministic repository understanding engine that pre-indexes your entire codebase into a local SQLite catalog. It acts as the Context Layer for your IDE, serving exactly the functions the AI needs—no more, no less—maximizing the first-try success rate and reducing token usage by 41-89%.

By combining AST body folding (which strips out function bodies while preserving signatures) with canonical determinism (which guarantees byte-identical outputs to maximize Anthropic's KV cache hits), Foldwork transforms massive enterprise monorepos into lightweight, cache-friendly payloads. This drastically reduces token consumption, cuts API costs by up to 90%, and eliminates context window overflow.

No cloud. No telemetry. Runs entirely on your machine.--

Estimate the impact of AST code compression on large open-source repositories (calculated at $2.00 / million input tokens for Claude Sonnet 5):

Numbers are reproducible. Run the open-source benchmark tool on any public repository:
mcp-benchmark repository

Runmcp-benchmarkon your own project to see your exact savings before installing anything:

mcp-benchmark ./your-project ════════════════════════════════════════════════════════════════════════════════ mcp-injector Benchmark — context Tier 3 compression | $2.00/1M tokens | 2026-07-15T12:00:00Z ════════════════════════════════════════════════════════════════════════════════ FILE RAW TOKENS COMPRESSED SAVED COST SAVED ────────────────────────────────────────────────────────────────────────────────────────── cmd/license-gen/main.go 3,633 214 94% $0.0072 main.go 17,555 1,917 89% $0.0347 website/api/webhook.go 2,682 295 89% $0.0053 main_test.go 1,576 353 78% $0.0031 ────────────────────────────────────────────────────────────────────────────────────────── TOTAL (4 files) 25,446 2,779 89.1% $0.0503  Based on $2.00 / 1M input tokens 💡 Running this codebase through Claude 10×/day costs $0.51/day raw. With mcp-injector: $0.01/day. You save $0.50/day ($15/month).

Returns a compressed structural overview of the workspace. Function bodies are folded and replaced with placeholders to reduce token usage.

- tier(integer, optional): Compression tier to apply (default: 2).
- unfolded_files(array of strings, optional): Workspace-relative paths or glob patterns for files to serve at full resolution (uncompressed).
- path_prefixes(array of strings, optional): Scope the project map to specific microservices or packages, drastically reducing payload bloat.
- git_context: always includes current branch, changed files, and recent commits in the response.
- secrets_redacted: count of credentials automatically redacted before sending to Claude.

{ "tool": "get_project_map", "arguments": { "tier": 3, "unfolded_files": ["src/auth/handler.go", "/_test.go"], "path_prefixes": ["src/auth/"] } }

Retrieves the full uncompressed source of a file from the local cache.

- path(string, required): The workspace-relative path of the file to retrieve.
- retrievalKey(string, optional): The SHA-256 retrieval key returned in a prior compressed payload.
- start_line(integer, optional): 1-indexed start line for range retrieval.
- end_line(integer, optional): 1-indexed end line for range retrieval.
- expand_graph(boolean, optional): Resolves and appends cross-file dependencies (limited to 50 1st-degree dependencies).

BM25-ranked full-text symbol search over the local SQLite catalog. Supports FTS5 boolean logic (e.g.,user AND (auth OR login)).

- query(string, required): FTS5 query string (bare terms, "phrase", prefix).
- limit(integer, optional): Maximum results (default: 20).
- search_paths(array of strings, optional): Scope search to specific isolated directories.

Generates a Mermaid sequence diagram for a given symbol by traversing its outbound dependencies (halts after 500 nodes).

- symbol(string, required): The exact symbol name.
- max_depth(integer, optional): Maximum traversal depth (default: 3).
- include_primitives(boolean, optional): Include basic types (String, boolean) and framework boundaries.

Fallback for exact literal or regex searches against file contents. Bypasses FTS5 tokenization.

- query(string, required): The string or regex pattern to search for.
- is_regex(boolean, optional): Treats query as extended regex (-E).

Write a full file to disk. CRITICAL: Prevents data loss by intercepting and rejecting payloads containing compressed fold markers.

Analyzes the architectural impact of changing a symbol by traversing the dependency graph. Supports inbound and outbound directional traversal.

Integrates with local Git history to surface commit context, authorship, and code evolution directly into the LLM context.

Enables direct database introspection capabilities. Currently supports PostgreSQL and MySQL.CRITICAL:You must start the daemon with theFOLDWORK_DB_DSNenvironment variable set to your database connection string (e.g.postgres://user:pass@localhost:5432/dbname) to activate this tool.

Wipes the SQLite index cache and triggers a clean cold-start full re-index.

Returns index status, current compression ratio, total files indexed, and cache hit rate.

Read tools automatically wait for pending indexing implicitly. You never need to manually call this tool.

Install the daemon locally and configure your IDEs:

curl -fsSL https://foldwork.dev/install | sh

Automatically configuresClaude Desktop,Cursor IDE,VS Code,Devin Desktop, andAntigravity.

Step 1: Check if your project qualifies for the free tier

Run the benchmark CLI on your project to see your token savings and line count:

If your project is under 50,000 lines, mcp-injector is completely free. The benchmark output shows your exact line count.

curl -fsSL https://foldwork.dev/install | sh

The installer auto-detects Claude Desktop, Cursor, VS Code, Devin Desktop, and Antigravity and writes the MCP config automatically. You should see output like:

mcp-injector v0.2.0 installed to /usr/local/bin/mcp-injector Claude Desktop configured Cursor configured Restart your IDE and mcp-injector will be active.

The MCP server starts automatically when your IDE launches. No separate daemon process to manage.

"Use get_project_map to show me the structure of this project"

Claude will call the mcp-injector tool and return a compressed map of your entire codebase. If you see module names, entry points, and dependency information - it is working.

When Claude needs to see the complete implementation of a compressed function, it automatically callsinjector_retrieve. You can also trigger this explicitly:

"Show me the full implementation of UserService.java"

Claude will fetch the uncompressed source from the local cache.
Editing Code:You MUST use theinjector_write_filetool to edit code. If Claude tries to write back folded placeholders into your source code, the daemon will hard-reject the payload to protect you from data loss.

Or ask Claude directly: "Call injector_stats and tell me my current token savings."

Now that your AI has deterministic tools to search, traverse, and retrieve code, you can ask it high-level architectural questions that usually fail on raw codebases:

- Trace authentication flow— Ask the agent to map out your login sequence; it will useinjector_retrievewithexpand_graph=trueto traverse through middleware, validation, and database layers.
- Find dead code— The agent can leverageinjector_blast_radius(inbound traversal) to identify unused functions and isolated structs.
- Generate architecture diagrams— Tell your AI to "Generate a Mermaid diagram for this workflow"; it usesinjector_diagramto instantly draw the entire outbound execution sequence.
- Understand dependency graphs— Useinjector_blast_radiusto see exactly what services or packages rely on a specific core module.
- Locate implementations— The agent usesinjector_search(BM25 full-text indexing) to find exact function definitions across millions of lines of code.
- Refactor safely— Before making a breaking change, the agent checksinjector_blast_radiusto see every caller that will be impacted.
- Review pull requests— Instruct the agent to analyze your uncommitted changes or branch diff. It usesinjector_git_contextto understand recent commits and author intent alongside the code.
- Navigate large monorepos—get_project_mapgives the AI a compressed, birds-eye view of your entire architecture, allowing it to drill down into specific microservices usingpath_prefixes.

Sometimes you need Claude to see the exact implementation of a file while keeping the rest compressed. Use theunfolded_filesparameter:

"Get the project map but show me src/auth/handler.go at full resolution"

This passes"unfolded_files": ["src/auth/handler.go"]to get_project_map. That file is served raw; everything else stays compressed.

- "/_test.go"- all test files uncompressed
- "src/auth/.go"- all files in a directory uncompressed

mcp-injector installs apost-checkoutgit hook when it first runs. Branch switching automatically triggers a full re-index. You will see this in the daemon logs:

[mcp-injector] Branch switched to feature/auth-refactor, re-indexing... [mcp-injector] Re-index complete in 4.2s (47,293 lines indexed)

Enterprise security teams often block AI coding tools because developers accidentally leak sensitive credentials in their context window.

mcp-injector solves this locally. The daemon includes a built-in Shannon entropy filter that analyzes all AST strings and comments in real-time. If it detects high-entropy strings (like AWS Access Keys, SSH private keys, or database passwords), it dynamically redacts them as[REDACTED: high entropy]before*they ever leave your machine. Your API credentials are never sent to Anthropic.

If your codebase has a hardcoded API key or AWS credential, theget_project_mapresponse will include:

"secrets_redacted": 2, "files_with_redactions": ["config/db.go", "scripts/deploy.sh"]

The actual values are replaced with[REDACTED: high entropy]. Variable names are preserved so Claude still understands the code structure.

If the auto-installer does not detect your IDE, add this to your MCP config manually:

{ "mcpServers": { "mcp-injector": { "command": "/usr/local/bin/mcp-injector", "env": { "MCP_WORKSPACE": "/absolute/path/to/your/project", "FOLDWORK_DB_DSN": "postgres://user:pass@localhost:5432/dbname" } } } }

Note:VS Code supports"${workspaceFolder}", but Claude Desktop, Cursor, and Devin Desktop require a hardcoded absolute path to your project.

- Claude Desktop (Mac):~/Library/Application Support/Claude/claude_desktop_config.json
- Claude Desktop (Windows):%APPDATA%\Claude\claude_desktop_config.json
- Claude Desktop (Linux):~/.config/Claude/claude_desktop_config.json
- Cursor:~/.cursor/mcp.json
- VS Code:.vscode/mcp.json
- Devin Desktop:~/.codeium/windsurf/mcp_config.json
- Antigravity:~/.gemini/antigravity/mcp_config.json

- Incremental Parsing:Foldwork scans your repository instantly using a single-pass AST parser, identifying all interfaces, classes, and function signatures without blocking.
- Graph Generation:It deterministically builds two structures: a Symbol Graph for precise definitions, and a Dependency Graph tracking outbound caller/callee relationships.
- Local Catalog:The graphs are durably stored in a local SQLite FTS5 catalog. Indexing happens exactly once per file change, meaning zero overhead during AI prompts.
- MCP Serving:Your AI agent securely communicates with Foldwork via the Model Context Protocol, fetching sub-graphs in milliseconds without the code ever leaving your machine.
- Branch-Aware & Deterministic:Switching branches triggers automatic incremental re-indexing via git hooks. By guaranteeing byte-identical outputs across runs, Foldwork maximizes Claude'sKV prompt cachinghits.

Supports:Go, Python, TypeScript, JavaScript, Java, C++, C, C#, Rust.

- Free Tier:Workspaces under 50,000 total source lines (all tools and features fully active).
- Pro Tier ($12/month or $99/year):Unlocks unlimited workspace sizes and high-speed incremental diff indexing.
Activate Pro at foldwork.dev

You can runmcp-injector statusin your terminal at any time. This CLI dashboard visually proves your exact token savings and estimated dollars saved by comparing your raw codebase tokens against the AST-compressed tokens in real-time.

mcp-injector automatically redacts secrets and credentials before they reach Claude's context window:

- AWS access keys, GitHub PATs, Stripe secret keys
- JWT tokens and bearer tokens
- High-entropy strings detected via Shannon entropy analysis
- Private key headers (-----BEGIN RSA PRIVATE KEY-----)
- Air-Gapped Ready:Pro license validation uses strictly offline Ed25519 cryptography. The daemon never makes an outbound network request, even to verify your subscription.

Redacted content is replaced with[REDACTED BY MCP-INJECTOR]. A count of redactions is included in theget_project_mapresponse so you always know what was protected.

Your code never leaves your machine. Redaction happens locally before compression, and is always-on - it cannot be disabled.

# Remove binary sudo rm /usr/local/bin/mcp-injector # Remove index cache and logs rm -rf ~/.mcp-injector/ # Remove from IDE MCP config (edit manually): # Claude Desktop (Linux): ~/.config/Claude/claude_desktop_config.json # Claude Desktop (macOS): ~/Library/Application Support/Claude/claude_desktop_config.json # Cursor: ~/.cursor/mcp.json # VS Code: .vscode/mcp.json # Devin Desktop: ~/.codeium/windsurf/mcp_config.json # Antigravity: ~/.gemini/antigravity/mcp_config.json # (Remove the "mcp-injector" entry from mcpServers)

mcp-injector automatically redacts the following before your code reaches Claude:

Redacted values are replaced with[REDACTED BY MCP-INJECTOR]. File paths and variablenamesare never redacted - only the values.

Commercial. Free tier available. Source code not public.
Support Contact:foldwork@proton.me

This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.

MCP bridge that lets Claude Code delegate heavy tasks to the Antigravity CLI (agy) — purpose-built tools, model routing with fallback, session continuity, and output truncation to save Claude's context and tokens.

Local agent workbench bundling OpenHands, Goose, Aider, and ashlrcode against one local LLM, with ashlr-plugin MCP servers pre-wired.

An MCP server for the Calva VS Code extension, allowing AI assistants to interact with a live Clojure REPL.

A server for CodeFuse-CGM, a graph-integrated large language model designed for repository-level software engineering tasks.

Unified MCP server providing access to Claude Code, Codex, and Gemini CLIs through a single gateway. Features multi-LLM orchestration, persistent session management, async job execution with polling, approval gates, retry with circuit breakers, and token optimization. Install: npx -y llm-cli-gateway

Intelligent orchestration platform that routes tasks to the best AI model (Claude, Codex, Gemini, OpenCode) using LinUCB bandits, validates through consensus voting, and learns from outcomes. 29 MCP tools, dev pipeline, 8 memory backends.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

Command

Env

Step 1: Check if your project qualifies for the free tier

Install

More like this

Sentry

Github

Git

GitLab

Context 7

1Panel