Six MCP Servers Worth Keeping in Claude Code and What to Cut

A coding agent asked to grep a local src folder for a deprecated authentication function can end up somewhere strange. In one realistic case, the agent skips the filesystem, calls a Jira MCP server installed a week earlier and starts searching the ticket backlog for the function name. Typing /mcp explains why: 14 servers were running and exposed 73 tools. Around 50 visible tools is roughly where a model stops telling similar tools apart and starts guessing. On top of that, about 18,000 tokens per turn went to JSON schemas for tools nobody was using, before the first word was typed.

Whatever server gets connected, its tool list lands in the system prompt. If the goal is an agent that chooses correctly on the first try, those slots are a limited budget.

Context7 for current docs

Agents often write code against APIs that have since changed. Ask for a Supabase authentication flow and the output may use methods deprecated in 2025. Context7 addresses that by injecting version-pinned library documentation into the prompt.

# Add --scope project (or -s project) to write the entry into
# a committable .mcp.json instead of your personal ~/.claude.json.

# Context7 provides current, version-pinned library docs
# Canonical path is the installer (OAuth + generates an API key):
npx ctx7 setup

# Or wire the remote server manually (key from context7.com/dashboard):
claude mcp add --transport http context7 https://mcp.context7.com/mcp \
  --header "CONTEXT7_API_KEY: <YOUR_KEY>"

With it installed, the agent fetches live Markdown and writes the current implementation. You do have to trust its index, but for mainstream web frameworks it's the first server worth installing.

GitHub for issues and pull requests

Tell an agent to fix issue #8009 and it will usually stop and ask for the description, since it can't see the remote repository. GitHub's official MCP server exposes the issue tracker, pull requests and remote code search.

# GitHub — OFFICIAL server (issues, PRs, repo search).
# For Claude Code 2.1.1+:
claude mcp add-json github '{"type":"http","url":"https://api.githubcopilot.com/mcp","headers":{"Authorization":"Bearer <YOUR_GITHUB_PAT>"}}'

# For Claude Code 2.1.0 or earlier (legacy flag form):
# claude mcp add --transport http github https://api.githubcopilot.com/mcp -H "Authorization: Bearer <YOUR_GITHUB_PAT>"

After that, a request like "review PR #8042" works: the agent pulls the diff, reads reviewer comments, maps them to local files and applies edits. Use GitHub's own server in preference to older third-party wrappers.

Postgres MCP Pro for real schemas

An agent that guesses a database schema produces errors like column 'created_at' does not exist. Postgres MCP Pro gives it tools such as list_schemas and get_object_details, so it maps the real database before writing SQL.

# Postgres MCP Pro — schema-aware SQL, READ-ONLY restricted mode
pipx install postgres-mcp

# Add the server with the restricted access flag
claude mcp add postgres --env DATABASE_URI="postgresql://user:pass@localhost:5432/db" \
  -- postgres-mcp --access-mode=restricted

For staging or production, the --access-mode=restricted flag isn't optional. It disables INSERT, UPDATE and DELETE at the server level, so the agent can't drop tables while exploring.

Playwright MCP for verification

Agents will happily claim a CSS class fixed a layout bug without ever rendering the page. Playwright MCP makes the agent check its own work by driving a headless browser.

# Playwright (Microsoft) — agent drives a real browser to verify its own change
claude mcp add playwright npx @playwright/mcp@latest

Rather than interpreting a raw screenshot, the agent reads the accessibility tree, so it knows where a button sits in the DOM and whether a user can see it.

Playwright drives the browser and tests the DOM. Chrome DevTools MCP is a separate tool aimed at network and performance profiling. Add the DevTools server only when you're actively chasing network issues, since Playwright is better at visual verification.

Sentry for production errors

A minified React stack trace pasted into a terminal rarely helps because production builds strip source maps. Sentry's official MCP server brings the unminified trace, breadcrumbs and environment data into the context window.

# Sentry — OFFICIAL remote server; pulls live stack traces
# Triggers OAuth on first launch
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp

When a user reports a crash, the agent can be told to look at the latest frontend issue in Sentry, and it debugs using the exact line and the variable state at crash time.

Brave Search for fresh answers

Twenty minutes can vanish on a cryptic esbuild error when the fix sits in a GitHub issue opened two days earlier. The agent's training data was too old to know, so the developer has to leave the terminal and search by hand.

# Brave Search — OFFICIAL server from Brave (the @modelcontextprotocol/*
# package was archived May 2025)
# Requires a free API key from api-dashboard.search.brave.com
claude mcp add brave-search --env BRAVE_API_KEY="<YOUR_KEY>" \
  -- npx -y @brave/brave-search-mcp-server --transport stdio

This gives the agent a live web search tool. Faced with an obscure error, it pulls recent StackOverflow answers or provider status pages without leaving the terminal.

Lock down the configuration

Before adding more, fix the configuration and audit what's running. Adding --scope project to any install command writes the entry into a .mcp.json in the repository instead of the global ~/.claude.json, so the whole team shares the same toolset.

A reference file for the servers above, plus two flex slots, looks like this. The flex slots are the maintained Filesystem server for scoped access to directories outside the current project, and Sequential-thinking, which helps the agent track its own logic during massive refactors.

{
  "mcpServers": {
    "context7": {
      "type": "http",
      "url": "https://mcp.context7.com/mcp",
      "headers": { "CONTEXT7_API_KEY": "${CONTEXT7_API_KEY}" }
    },
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp",
      "headers": { "Authorization": "Bearer ${GITHUB_PAT}" }
    },
    "sentry": {
      "type": "http",
      "url": "https://mcp.sentry.dev/mcp"
    },
    "postgres": {
      "command": "postgres-mcp",
      "args": ["--access-mode=restricted"],
      "env": { "DATABASE_URI": "${DATABASE_URI}" }
    },
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@brave/brave-search-mcp-server", "--transport", "stdio"],
      "env": { "BRAVE_API_KEY": "${BRAVE_API_KEY}" }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "${HOME}/projects"]
    },
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}

The entries use two transports. With http, the server is a remote API and all of its logic executes on the provider's side. With stdio, as for Playwright or Postgres, a local process is launched from the command array, so the matching binaries have to be installed on the machine first. Secrets arrive through environment interpolation such as ${DATABASE_URI}, which keeps the file safe to commit.

To see what the setup costs in tool count, check the live session:

# List every configured server and its connection status
claude mcp list

# Inside a Claude Code session, inspect connected servers and their tools:
# Type /mcp
# This shows each server, its tool count, and lets you toggle tools.

Add up the tool counts the interface shows. Near fifty visible tools, disable whatever isn't needed for that session.

Prune the dead weight

With a baseline in place, remove what doesn't belong.

• Archived reference servers. The old Postgres implementation (@modelcontextprotocol/server-postgres) still appears in outdated tutorials but is unmaintained. Replace it with Postgres MCP Pro.
• Third-party wrappers. Community wrappers for GitHub, Sentry and similar services arrived in 2025 as stopgaps and lag official API changes. Wherever an official vendor server exists, drop the community fork.
• Anything duplicating built-in abilities. This is where tool collisions happen. A dedicated shell execution server gives the agent two ways to run bash. One documented failure had an agent use a third-party execute_script tool for a simple npm install, hit a path error and then write a custom Python script to trigger the install, ignoring the native shell. If the client can already fetch URLs or read files, don't spend allowance on a server that does the same.

Keep auditing

Re-check .mcp.json whenever a session feels sluggish. A healthy setup keeps the six core servers above and leaves headroom under the 50-tool threshold. A Slack MCP server is a typical casualty: the agent keeps reading channel history when asked to search local logs, so it goes. A candidate for the eighth slot, such as Linear's MCP for pulling acceptance criteria into the editor, has to earn its place, and if it pushes the count too high, something else leaves.

When an agent feels slow lately, save the current configuration, then try just these core servers for a few days. Run /mcp to see the footprint and notice whether the model picks tools more crisply. Bring other servers back only after hitting a limit that built-in Claude Code features can't get past.