Best MCP Servers Worth Installing (And 5 That Waste Your Context Window)

What Makes an MCP Server Worth Keeping#

Every MCP server injects its full tool schema into every message you send. That means tool names, descriptions, JSON parameter definitions, and system instructions all eating context before you type a single prompt. A lightweight server costs 400 tokens per turn. A heavy one costs 3,500+.

I evaluate servers on three criteria. Does it save me tool calls I would otherwise do manually? Does it stay quiet when unused, meaning it does not inject noisy schemas for features I rarely touch? And does the context cost justify what it does?

If a server fails any of those, it gets removed. A server that registers 40+ tools but you only use 3 is a net negative. You are paying the token tax on all 40 definitions every single turn.

The MCP Servers I Keep Installed#

These are ranked by how often I actually use them, not by GitHub stars or hype. Every one of these earns its context cost daily.

• Context7 -- fresh docs on demand, ~550 tokens
• Playwright -- browser automation, ~3,500 tokens
• GitHub -- PRs, issues, CI, ~1,800 tokens
• Postgres / Supabase -- direct DB queries, ~500 tokens
• Filesystem -- cross-project file access, ~450 tokens
• Notion -- knowledge base sync, ~1,200 tokens
• Brave Search -- web lookups, ~600 tokens

Context7#

Stale docs are the number one source of AI coding errors. Context7 fetches current documentation for any library on demand, so Claude stops hallucinating deprecated APIs. Two tools, low schema overhead, massive impact.

"context7": {
  "type": "stdio",
  "command": "npx",
  "args": ["-y", "@upstash/context7-mcp"]
}

Playwright#

Browser automation without leaving your terminal. I use this for testing flows, scraping docs pages, and verifying UI changes. It costs roughly 3,500 tokens per turn, which is the most expensive server I keep. The tradeoff is worth it because the alternative is switching context to a browser constantly.

GitHub#

Reading issues, creating PRs, checking CI status, and reviewing diffs without opening a browser tab. The official GitHub MCP server has 28,000+ stars for a reason. It registers 51 tools, which is a lot, but Claude Code's tool search loads only what you need per task.

Postgres and Supabase#

Direct database queries from Claude. I reach for this when debugging data issues or writing migrations. The Postgres server is especially lean at under 500 tokens for its schema. Supabase adds table design and project management tools on top.

Filesystem#

Claude Code already reads files, but the filesystem MCP server handles operations outside your project directory. Useful when you need to access config files, dotfiles, or assets from other repos. Tiny token footprint.

Notion#

If your team stores specs or docs in Notion, this server lets Claude search pages, read database entries, and create content. I use it for syncing project data. The token cost is moderate and the time it saves on copy-pasting from Notion is significant.

Brave Search#

Web search from inside Claude Code. Faster than switching to a browser for quick lookups, and the results feed directly into Claude's context. Cheap at around 600 tokens for its schema definition.

Tip: If you want to reduce your token overhead from MCP servers, start with zero servers and add one at a time. Measure context cost after each addition using the command in the section below.

The 5 That Waste Your Context Window#

These servers are not broken. They work fine in isolation. The problem is their context cost relative to what they deliver inside Claude Code specifically.

• Jira MCP registers 40+ tools and consumes roughly 17,000 tokens per turn. That is 8.5% of your 200K context window gone before you ask anything. For most developers, the Jira web UI or a simple API call is faster and free of context overhead.
• Gmail MCP looks small with only 7 tools, but its complex schema definitions cost 2,640 tokens. Checking email from your coding agent is a novelty, not a workflow. Your inbox can wait.
• Slack MCP dumps channel history and message schemas into context. I tried it for two weeks. Claude spent more tokens parsing Slack metadata than writing code. Use the Slack app.
• Generic "everything" servers like all-in-one API hubs register hundreds of tools. Pipedream's MCP exposes 8,000+ tools across 2,500 APIs. Even with tool search, the index overhead is brutal. Pick the specific server for the API you need instead.
• Calendar/scheduling servers add meeting, event, and attendee schemas that are irrelevant to coding. If you are asking Claude Code to schedule your meetings, you have bigger problems than context waste.

The common pattern here: servers built for general AI assistants, not for coding agents. Claude Code needs tools that help with code, infrastructure, and documentation. Everything else is dead weight in your context window.

How to Check Your MCP Context Cost#

You cannot optimize what you do not measure. Claude Code gives you a way to see exactly how much context each MCP server consumes per turn. Run /cost in any conversation to see your current token breakdown.

For a more precise measurement, start a fresh conversation with all your servers enabled and check the system prompt size. Then disable servers one at a time and compare.

# Check which MCP servers are loaded and their tool counts
claude mcp list

# Start claude with verbose token logging
claude --verbose

# Inside a session, check context usage
/cost

Tool search activates automatically when your tool definitions exceed 10% of the context window. It requires Sonnet 4 or Opus 4. If you are on an older model, every tool definition loads into every message regardless of whether you use it. That is where the real waste happens.

Note: Tool search reduced one developer's context overhead from 72,000 tokens to about 8,700 tokens. If you run 5+ servers, upgrading to a model that supports tool search is not optional. Read more in my Claude Code tips guide.

My Recommended Setup#

This is the exact MCP configuration in my settings.json right now. Five servers for daily use, two more enabled on a per-project basis. Total baseline cost sits around 6,000 tokens per turn, which is under 3% of the context window.

{
  "mcpServers": {
    "context7": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"]
    },
    "github": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "ghp_your_token" }
    },
    "postgres": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": { "DATABASE_URL": "postgresql://..." }
    },
    "filesystem": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home"]
    },
    "brave-search": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-brave-search"],
      "env": { "BRAVE_API_KEY": "your_key" }
    }
  }
}

Playwright and Notion live in project-level .claude/settings.json files where I actually need them. No reason to load browser automation tools when I am writing a CLI app. If you want to build your own servers instead of using community ones, I wrote a full guide on building an MCP server from scratch.

The chart tells the story. Jira alone costs more than my entire recommended setup combined. Pick servers that sit on the left side of that chart, and add the expensive ones only when a project demands them.

The Short Version#

Start with zero MCP servers. Add Context7 first because stale docs cause more bugs than anything else. Add GitHub and Postgres when your workflow needs them. Keep Playwright and Notion in project-level configs.

Remove anything that registers 20+ tools you never use. Measure context cost with /cost after every change. The best MCP servers are the ones you forget are running because they do their job without eating your budget.

TL;DR: Keep Context7, GitHub, Postgres, Filesystem, and Brave Search as your baseline. Add Playwright and Notion per-project. Avoid Jira, Gmail, Slack, mega-hub servers, and calendar integrations. Measure everything with /cost.