lean-ctx MCP — Use Cases, Install & Live Demo

Why use it

Key features

42 MCP tools: 8 file read modes, smart search, session memory, multi-agent sharing
Shell hook compresses 90+ CLI command patterns (git, docker, npm, cargo, etc.)
8 file read modes: full, map, signatures, diff, aggressive, entropy, task, lines
Single Rust binary — fast startup, <1ms overhead, zero telemetry
One-command setup for 24 AI coding tools
Tree-sitter AST parsing for 18 languages

Live Demo

What it looks like in practice

lean-ctx.replay ▶ ready

0/0

Install

Pick your client

~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "lean-ctx": {
      "command": "TODO",
      "args": [
        "See README: https://github.com/yvgude/lean-ctx"
      ],
      "_inferred": true
    }
  }
}

Open Claude Desktop → Settings → Developer → Edit Config. Restart after saving.

~/.cursor/mcp.json · .cursor/mcp.json

{
  "mcpServers": {
    "lean-ctx": {
      "command": "TODO",
      "args": [
        "See README: https://github.com/yvgude/lean-ctx"
      ],
      "_inferred": true
    }
  }
}

Cursor uses the same mcpServers schema as Claude Desktop. Project config wins over global.

VS Code → Cline → MCP Servers → Edit

{
  "mcpServers": {
    "lean-ctx": {
      "command": "TODO",
      "args": [
        "See README: https://github.com/yvgude/lean-ctx"
      ],
      "_inferred": true
    }
  }
}

Click the MCP Servers icon in the Cline sidebar, then "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "lean-ctx": {
      "command": "TODO",
      "args": [
        "See README: https://github.com/yvgude/lean-ctx"
      ],
      "_inferred": true
    }
  }
}

Same shape as Claude Desktop. Restart Windsurf to pick up changes.

~/.continue/config.json

{
  "mcpServers": [
    {
      "name": "lean-ctx",
      "command": "TODO",
      "args": [
        "See README: https://github.com/yvgude/lean-ctx"
      ]
    }
  ]
}

Continue uses an array of server objects rather than a map.

~/.config/zed/settings.json

{
  "context_servers": {
    "lean-ctx": {
      "command": {
        "path": "TODO",
        "args": [
          "See README: https://github.com/yvgude/lean-ctx"
        ]
      }
    }
  }
}

Add to context_servers. Zed hot-reloads on save.

claude mcp add lean-ctx -- TODO 'See README: https://github.com/yvgude/lean-ctx'

One-liner. Verify with claude mcp list. Remove with claude mcp remove.

Use Cases

Real-world ways to use lean-ctx

How to cut your AI coding costs by 80%+ with lean-ctx

👤 Developers paying for Claude, Cursor, or Copilot API tokens ⏱ ~10 min beginner

When to use: Your monthly AI coding bill is growing and you want to reduce it without changing your workflow.

Prerequisites

lean-ctx installed — brew install lean-ctx or curl -fsSL https://leanctx.com/install.sh | sh

Flow

One-command setup

Run: lean-ctx setup✓ Copied

→ Shell hooks installed, all detected editors configured automatically
Code normally for a day

Use your AI coding tool as usual — lean-ctx works transparently in the background.✓ Copied

→ No workflow change; compression happens silently
Check savings

Run: lean-ctx gain✓ Copied

→ Dashboard showing token savings per category (file reads, git, shell, etc.)

Outcome: Measurable token reduction (typically 60-90%) with zero workflow friction.

Pitfalls

Compressed output confuses some edge-case prompts — Use lean-ctx-off to temporarily disable, or use ctx_read with 'full' mode for specific files

Read large codebases efficiently with 8 file modes

👤 AI coding tool users working on large repos ⏱ ~5 min beginner

When to use: Your AI assistant wastes tokens reading entire files when it only needs the structure or signature.

Flow

Use map mode for overview

lean-ctx read src/main.rs -m map✓ Copied

→ File structure at ~10% of full token cost
Use signatures mode for API

lean-ctx read src/lib.rs -m signatures✓ Copied

→ Just function/type signatures, no bodies
Use diff mode for changes

lean-ctx read src/main.rs -m diff✓ Copied

→ Only lines changed since last read — minimal tokens

Outcome: The AI gets exactly the context it needs at a fraction of the token cost.

Pitfalls

Aggressive mode strips too much for complex refactoring — Use 'task' mode instead — it preserves context relevant to the current task

Combine with: filesystem

Combinations

Pair with other MCPs for X10 leverage

lean-ctx + filesystem

Use lean-ctx for token-efficient reads and filesystem MCP for writes — best of both worlds

Use ctx_read to analyze the codebase structure efficiently, then use filesystem MCP to apply the refactoring changes.✓ Copied

lean-ctx + github

lean-ctx compresses local context, GitHub MCP handles remote operations — minimizing total tokens

Use ctx_overview to understand the project, then use GitHub MCP to create a well-informed PR description.✓ Copied

Tools

What this MCP exposes

Tool	Inputs	When to call	Cost
ctx_read	file: str, mode: full\|map\|signatures\|diff\|aggressive\|entropy\|task\|lines	Read a file with controlled verbosity	0 — local cached read
ctx_multi_read	files: str[], mode?: str	Read multiple files in one call	0
ctx_tree	path: str	Get project structure	0
ctx_search	query: str, path?: str	Find patterns in code	0
ctx_smart_read	file: str, intent: str	Read with task-aware filtering	0
ctx_shell	command: str	Run shell commands with output compression	0
ctx_overview	path: str	Get a high-level project overview	0
ctx_session	-	Manage context across conversation turns	0
ctx_cost	-	Track how much you've saved	0

Cost & Limits

What this costs to run

API quota: No external API — everything runs locally.
Tokens per call: That's the point: ctx_read in map mode uses ~10% of the tokens a full read would. Shell compression saves 60-95%.
Monetary: Free and open-source (MIT). Saves $30-100+/month on AI coding API costs for active developers.
Tip: Use 'map' mode as default for exploration, 'full' only when you need every line. The savings compound fast.

Security

Permissions, secrets, blast radius

Credential storage: No credentials needed. Purely local tool.

Data egress: Zero. No telemetry, no analytics, no network requests. Everything stays on your machine.

Shell hooks modify your .zshrc/.bashrc — a backup is created at ~/.zshrc.lean-ctx.bak before any changes.
If a shell command breaks after install, run lean-ctx-off to temporarily disable hooks.

Troubleshooting

Common errors and fixes

Shell commands produce garbled output

Run lean-ctx setup to update hooks to the latest version. If persists, run lean-ctx-off to disable temporarily.

Verify: lean-ctx doctor

MCP server not detected by editor

Run lean-ctx setup again — it auto-configures all detected editors. For manual setup: claude mcp add lean-ctx lean-ctx

Verify: lean-ctx doctor

Binary not found after install

Shell aliases auto-fallback safely. Re-run the install script or brew reinstall lean-ctx.

Verify: which lean-ctx

ctx_read returns stale content

lean-ctx tracks file mtime for cache invalidation. If you edited outside the normal flow, touch the file to reset the mtime.

Verify: lean-ctx cache --status

Alternatives

lean-ctx vs others

Alternative	When to use it instead	Tradeoff
Rust Token Killer	You want a similar concept with different tradeoffs	Fewer tools (~50 patterns vs 42 tools), 3 editor support vs 24, has default-on telemetry with PII
Manual .cursorrules / CLAUDE.md context management	You prefer manual context curation	No automatic compression; no caching; more work

More

Resources

📖 Read the official README on GitHub

🐙 Browse open issues

🔍 Browse all 400+ MCP servers and Skills