Skip to main content
skill CX Codex

mcp-audit · rohitg00 — Claude Code skill: analyze MCP servers

mcp-audit analyzes connected MCP servers for token overhead, redundancy, and unused configurations. Run when sessions slow down or before connecting a new server.

MIT ★ 2,966 updated 2026-09-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add rohitg00/pro-workflow
/plugin install pro-workflow@pro-workflow
Open on GitHub

What mcp-audit does

Every MCP server adds all its tool descriptions to every API request. A server with 20 tools consumes 2–4K tokens per request, whether you use it or not. The skill lists active servers, counts tools per server, estimates token cost, and recommends which ones to disable or consolidate.

The audit checks your MCP configs, estimates overhead by tool count (1–5 tools is low; 30+ is problematic), identifies which servers were actually used, and flags overlapping ones. Output shows token savings per request and projected cost reduction per session.

Keeps servers with small tool sets and those needed every session (filesystem, Git). Triggers concern when you exceed 15 active servers, more than 80 total tools, or any single server with 30+ tools.

What it helps with

  • identify MCP servers that slow down your session
  • calculate token cost added by each server's tool descriptions
  • remove unused servers without losing functionality
  • spot servers with overlapping capabilities

Example prompts for the agent

  • Audit my MCP servers and show token overhead
  • How many tools does each of my MCP servers have and how much do they cost?
  • Which MCP servers should I disable to speed up my sessions?

How to install mcp-audit

1Plugin marketplace

/plugin marketplace add rohitg00/pro-workflow
/plugin install pro-workflow@pro-workflow

This installs the whole pro-workflow plugin with all its skills

2Skills CLI (Vercel)

npx skills add rohitg00/pro-workflow --skill mcp-audit -a claude-code

3Manually: put the files in place

~/.claude/skills/mcp-audit/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/mcp-audit/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about mcp-audit

How do I install mcp-audit in Claude Code?

Run these commands in order: /plugin marketplace add rohitg00/pro-workflow, then /plugin install pro-workflow@pro-workflow. Alternatively use npx skills add rohitg00/pro-workflow --skill mcp-audit -a claude-code. The skill will be installed to ~/.claude/skills/mcp-audit/SKILL.md.

What does mcp-audit do?

It scans all your connected MCP servers, counts the tools in each, estimates token cost per request, and recommends which servers to disable based on disuse (7+ days inactive), functional overlap with other servers, or excessive tool count.

When does mcp-audit recommend disabling a server?

When the server has not been used in over 7 days, its capabilities overlap with another active server, or it is project-specific and you are working in a different project. The skill always asks for confirmation before changes.

Source text

SKILL.md · MIT
---
name: mcp-audit
description: Audit connected MCP servers for token overhead, redundancy, and security. Use when sessions feel slow or before adding new MCPs.
user-invocable: true
---

# MCP Audit

Analyze MCP server overhead and recommend cleanup.

## Trigger

Use when:
- Sessions feel slow or expensive
- Adding a new MCP server
- Context fills up quickly
- Reviewing project configuration

## Key Insight

Each MCP server adds ALL its tool descriptions to every API request. A server with 20 tools adds ~2K-4K tokens per request, regardless of whether you use those tools.

## Audit Steps

### Step 1: List Active Servers

Check all MCP configurations:
```bash
cat .claude/settings.json 2>/dev/null | grep -A 50 "mcpServers"
cat ~/.claude/settings.json 2>/dev/null | grep -A 50 "mcpServers"
```

### Step 2: Count Tools Per Server

For each server, estimate token overhead:
- 1-5 tools: ~200-500 tokens (low overhead)
- 6-15 tools: ~500-1500 tokens (moderate)
- 16-30 tools: ~1500-3000 tokens (high)
- 30+ tools: ~3000+ tokens (excessive — consider tool filtering)

### Step 3: Check Usage

Questions to ask:
- Which servers were actually used this session?
- Which servers haven't been used in 7+ days?
- Are there servers with overlapping functionality?
- Are there servers only needed for specific tasks?

### Step 4: Recommend Actions

**Disable** servers that:
- Haven't been used in 7+ days
- Overlap with another active server
- Are project-specific but you're in a different project

**Keep** servers that:
- Are used every session (filesystem, git)
- Provide unique capabilities needed for current work
- Have low tool count (<5 tools)

## Output

```text
MCP AUDIT
  Active servers: [N]
  Total tools: [N]
  Estimated overhead: ~[N]K tokens per request

  Server Analysis:
    [name] — [N] tools, ~[N] tokens
      Status: KEEP / DISABLE / REVIEW
      Reason: [why]

  Recommendations:
    Disable: [list]
    Keep: [list]
    Review: [list]

  Projected savings: ~[N]K tokens per request (~$X.XX per session)
```

## Thresholds

- Total servers: <10 (ideal), 10-15 (monitor), >15 (reduce)
- Total tools: <80 (ideal), 80-120 (monitor), >120 (reduce)
- Per-server: <15 tools (ok), 15-30 (filter), >30 (split or disable)

## Rules

- Never disable servers without user confirmation
- Estimate token savings for each recommendation
- Consider task context — a server might be unused today but critical tomorrow
- Check for `disabledMcpjsonServers` to avoid re-recommending already-disabled servers

© Rohit Ghumare · MIT · rohitg00/pro-workflow

Similar skills

All skills for Agent setup: memory, context, orchestration →

mcp-audit by other authors comes first.

mcp-audit hoangsonww Audits user- and project-scoped MCP servers via the Agent Monitor API. Identifies transport issues, duplicate configurations, and external HTTP endpoints. CX Codex +1 ★ 1,198repo stars context-tax-audit Ronny (MiniMax Code team) The context-tax-audit skill for Claude Code inventories injected data in agent requests to reduce token usage. It identifies redundant prompt blocks and configurations that hinder prompt cache performance. CX Codex +1 ★ 741repo stars token-efficiency Delphine-L token-efficiency — a Claude Code skill that cuts unnecessary file reads and command output. It guides token-conscious codebase exploration and development. CX Codex +1 2,700installs token-optimizer alexgreensh token-optimizer — a skill for Claude Code and Codex that tracks where the context window goes, suggests fixes, and applies the ones you approve. Kick it off when sessions feel tight or the bill starts climbing. CX Codex +1 1,100installs context-optimization muratcankoylan context-optimization extends useful context capacity through observation masking, KV-cache reuse, compaction, and task partitioning across sub-agents. CX Codex +1 532installs audit-session-metrics centminmod Reads a session-metrics JSON export and reports on token-usage waste. Invoke it with /audit-session-metrics quick or detailed against a finished export file. CX Codex +1 ★ 2,744repo stars performance-audit davila7 performance-audit audits codebase performance, locating slow database queries, nested loops, and build bottlenecks. Prioritizes optimizations by system impact and implementation effort. CX Codex +1 661installs

From the same set83

The whole set →
pre-flight-discipline The pre-flight-discipline rule makes Claude Code surface assumptions, limit edits to the request, and verify multi-step work. It fits projects where drive-by changes are a concern. CX Codex +1 ★ 2,966repo stars smart-commit smart-commit runs lint, typecheck and tests before a commit, scans staged code for leftovers, then writes a conventional commit message from the diff. CX Codex +1 ★ 2,966repo stars file-watcher file-watcher configures Claude Code hooks to react to changes in configuration files, dependencies, and environment files. CX Codex +1 ★ 2,966repo stars commit Runs project checks, reviews staged changes, and creates a focused git commit. Use it when a change is ready to be recorded. CX Codex +1 ★ 2,966repo stars tdd tdd guides Claude Code through a strict test-driven development loop: write a failing test, pass it with minimal code, and clean up. CX Codex +1 ★ 2,966repo stars module-shape The module-shape rule keeps public module APIs small while hiding complexity inside. Use it when designing modules or reviewing tests and dependencies. CX Codex +1 ★ 2,966repo stars improve-architecture improve-architecture audits code structure, identifies tangles in boundaries and dependencies, and proposes a ranked list of minimal moves that relieve the strain—no rewrite, only a plan you approve first. CX Codex +1 ★ 2,966repo stars parallel-worktrees parallel-worktrees — a skill for Claude Code that creates isolated git worktrees for parallel coding sessions. While tests or builds run in one window, start a new task in another without waiting or switching context. CX Codex +1 ★ 2,966repo stars

Project sponsors

Companies that keep this analytics open