Best MCP Servers for Claude Code: A Developer's Guide

Claude Code is a capable coding agent on its own — it can read your codebase, write and edit files, run tests, and fix bugs. But it is operating on guesswork when it comes to anything outside the local filesystem: your GitHub issues, your database schema, your open tickets, your test suite in a real browser. MCP servers eliminate that guesswork by giving Claude Code structured, real-time access to the tools and data sources your project actually depends on. The difference between Claude Code without MCP and Claude Code with a well-chosen set of MCP servers is the difference between a contractor who has never visited the job site and one who has a full set of blueprints.

This guide covers the best MCP servers for Claude Code in 2026 — what each one does, why it matters for day-to-day development work, and exactly how to add it. If you are new to the protocol itself, start with our MCP developer guide for the conceptual foundation, then come back here for the practical setup.

How to Add an MCP Server to Claude Code

Claude Code ships with a built-in CLI command for adding MCP servers. The simplest form is a single command that registers the server globally (available in every project) or locally (scoped to the current directory). For remote servers that use Streamable HTTP transport — like AppHandoff — you pass the URL directly. For local servers that run as a subprocess — like the GitHub or PostgreSQL servers — you pass the command and arguments.

# Add a remote MCP server (Streamable HTTP)
claude mcp add apphandoff https://api.apphandoff.com/api/mcp-bot

# Add a local subprocess MCP server
claude mcp add github npx -y @modelcontextprotocol/server-github

# Add with environment variables
claude mcp add postgres npx -y @modelcontextprotocol/server-postgres \
  --env DATABASE_URL=postgresql://reader:pass@localhost:5432/mydb

# List all registered MCP servers
claude mcp list

# Scope a server to the current project only (instead of --global)
claude mcp add --scope project github npx -y @modelcontextprotocol/server-github

The claude mcp add command writes to your Claude Code configuration and makes the server available immediately — no restart required. Servers added with --scope project are stored in .claude/settings.json at your project root, which you can commit to share the configuration with your team.

GitHub MCP Server

The GitHub MCP server is the single most impactful addition for most developers. It gives Claude Code access to your repositories, issues, pull requests, and code search through the GitHub API. With it, Claude Code can read the full history of an issue before implementing a fix, check whether a PR is open before referencing it, search your org's codebase for existing implementations, and create or update issues as part of a workflow.

Without the GitHub MCP server, Claude Code's knowledge of your GitHub state is frozen at the last context you manually pasted in. With it, the agent can ask GitHub directly. For teams using GitHub Projects or GitHub Actions, the server also exposes workflow run status so Claude Code can check whether CI passed before suggesting a merge.

# Install and add the GitHub MCP server
claude mcp add github npx -y @modelcontextprotocol/server-github \
  --env GITHUB_TOKEN=ghp_your_personal_access_token

# Or add to .claude/settings.json for project-scoped setup
# "mcpServers": {
#   "github": {
#     "command": "npx",
#     "args": ["-y", "@modelcontextprotocol/server-github"],
#     "env": { "GITHUB_TOKEN": "ghp_your_personal_access_token" }
#   }
# }

Create a GitHub personal access token with repo and read:org scopes for read-only access, or add issues:write and pull_requests:write if you want Claude Code to create issues and open PRs on your behalf. See the full setup walkthrough in our GitHub MCP server guide.

PostgreSQL MCP Server

The PostgreSQL MCP server gives Claude Code live schema awareness. It connects to your database using a read-only role and exposes tools for listing tables, describing columns and constraints, viewing foreign key relationships, and running SELECT queries. This is essential for any task involving database work: writing migrations, building API endpoints, debugging query issues, or understanding data relationships.

The critical detail is the read-only role. You should connect the MCP server using a database user that has only SELECT privileges — enforced at the Postgres level with GRANT SELECT, not just in application code. This ensures that even if an agent is manipulated into calling the query tool with a destructive statement, the database rejects it. Full setup instructions, including creating the read-only role, are in our PostgreSQL MCP guide.

# Create a read-only Postgres role first
# psql -c "CREATE ROLE mcp_reader WITH LOGIN PASSWORD 'yourpass';"
# psql -c "GRANT SELECT ON ALL TABLES IN SCHEMA public TO mcp_reader;"

# Add the PostgreSQL MCP server
claude mcp add postgres npx -y @modelcontextprotocol/server-postgres \
  --env DATABASE_URL=postgresql://mcp_reader:yourpass@localhost:5432/yourdb

Supabase MCP Server

If your project uses Supabase, the official Supabase MCP server is a more capable replacement for the generic PostgreSQL server. It exposes not just schema and query tools, but also Supabase-specific capabilities: listing projects, inspecting edge functions, checking migration history, retrieving publishable API keys, and reading project logs. For full-stack projects built on Supabase, this gives Claude Code a much richer picture of the backend.

The Supabase MCP server authenticates via a Supabase personal access token and connects to both the Supabase Management API and your project's database. It is particularly useful when Claude Code needs to understand the full stack context — not just what tables exist, but what edge functions are deployed, what migrations have been applied, and whether the project is healthy.

# Add the Supabase MCP server
claude mcp add supabase npx -y @supabase/mcp-server-supabase \
  --env SUPABASE_ACCESS_TOKEN=sbp_your_personal_access_token

# The server auto-discovers your projects from the access token
# To scope to a specific project, pass the project ref:
# --env SUPABASE_PROJECT_REF=yourprojectref

Linear MCP Server

Linear is where many engineering teams track their work — sprints, epics, bugs, features. The Linear MCP server connects Claude Code to that context. With it, the agent can read the full description and comments on a ticket before implementing it, check the current sprint to understand priorities, create sub-issues for tasks it discovers while working, and update ticket status as work progresses.

The practical impact is that Claude Code moves from implementing what you describe in a prompt to implementing what the ticket actually specifies — including acceptance criteria, linked design decisions, and comments from the last standup. For teams that keep their Linear tickets well-maintained, this is one of the highest-leverage MCP additions available.

# Add the Linear MCP server
claude mcp add linear npx -y @linear/mcp-server \
  --env LINEAR_API_KEY=lin_api_your_api_key

# Generate an API key at: https://linear.app/settings/api

Playwright MCP Server

The Playwright MCP server gives Claude Code control of a real browser. It exposes tools for navigating to URLs, clicking elements, filling forms, taking screenshots, and reading the DOM. This unlocks an entirely new class of tasks: writing and running end-to-end tests, verifying that a UI change looks correct, scraping data from pages that require JavaScript rendering, or debugging an issue that only appears in a real browser.

For testing workflows, the Playwright MCP server is particularly powerful. Claude Code can write a test, execute it in the browser, see the failure screenshot, fix the implementation, and re-run — all in a single agent session without you ever switching context. This is dramatically faster than the write-run-read-fix cycle of traditional test authoring.

# Add the Playwright MCP server
claude mcp add playwright npx -y @playwright/mcp

# Run in headless mode (no visible browser window)
claude mcp add playwright npx -y @playwright/mcp -- --headless

# The server exposes tools like:
# - browser_navigate(url)
# - browser_click(selector)
# - browser_take_screenshot()
# - browser_fill_form(selector, value)
# - browser_snapshot() -- accessibility tree for element inspection

Filesystem MCP Server

Claude Code has built-in filesystem access, but the standalone Filesystem MCP server adds scoped, configurable file access that is useful in specific scenarios: giving an agent access to a directory outside the current project, restricting access to a specific subdirectory, or exposing a shared config directory across multiple projects. It is the simplest MCP server to set up and the one most likely to already be running without explicit configuration.

The key configuration parameter is the allowed paths list. You pass the directories the server can access as arguments. This is enforced in the server — reads and writes outside the allowed paths return permission errors. For agents working in monorepos, scoping the filesystem server to the relevant package directory (rather than the repo root) reduces noise from unrelated packages.

# Add the Filesystem MCP server scoped to src/ and docs/
claude mcp add filesystem npx -y @modelcontextprotocol/server-filesystem \
  ./src ./docs

# For absolute paths
claude mcp add filesystem npx -y @modelcontextprotocol/server-filesystem \
  /Users/yourname/projects/myapp/src

AppHandoff MCP Server

AppHandoff's MCP server is the coordination layer that connects Claude Code to your full development workflow. Where GitHub gives you code and issues, and Linear gives you tickets, AppHandoff gives you the contract between your frontend and backend — API specs, type mismatches, scan results, and handoff tickets that track what each agent session was supposed to accomplish and what it actually did.

The 30+ tools cover project context (API specs, DB schema summaries, frontend snapshots), ticket management (create, update, close handoff tickets with AI-inferred resolution types), mismatch detection (frontend calling an endpoint that doesn't exist, or with the wrong type shape), deployment checks, and cross-agent coordination. For teams where multiple AI agents are working in parallel — a Claude Code session on the backend, a Cursor session on the frontend, a Codex session writing tests — AppHandoff is how they stay in sync.

# Add the AppHandoff MCP server
claude mcp add apphandoff https://api.apphandoff.com/api/mcp-bot

# AppHandoff uses OAuth for authentication.
# On first use, Claude Code will prompt you to authenticate
# via the AppHandoff portal at portal.apphandoff.com.

# Once authenticated, tools are immediately available:
# - get_app_analysis      -- full project contract summary
# - get_mismatches        -- frontend/backend type conflicts
# - get_handoff_requests  -- open tickets for this project
# - create_handoff_task   -- create a ticket for current work
# - get_api_spec          -- OpenAPI spec for your backend

AppHandoff MCP connects to your project automatically once authenticated — no manual project ID configuration needed for most workflows. The full tool reference is at /mcp-server, and the step-by-step connection guide for Claude Code, Cursor, and Codex is at /blog/connect-claude-cursor-codex-to-apphandoff-mcp.

How to Configure Multiple MCP Servers

Once you have more than two or three MCP servers, managing them via individual claude mcp add commands becomes unwieldy. The better approach is to define them in .claude/settings.json at your project root. This file is committed to the repository, so every team member (and every agent session in that repo) automatically gets the same MCP configuration.

// .claude/settings.json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": { "DATABASE_URL": "${DATABASE_URL}" }
    },
    "linear": {
      "command": "npx",
      "args": ["-y", "@linear/mcp-server"],
      "env": { "LINEAR_API_KEY": "${LINEAR_API_KEY}" }
    },
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp", "--headless"]
    },
    "apphandoff": {
      "type": "http",
      "url": "https://api.apphandoff.com/api/mcp-bot"
    }
  }
}

Environment variable interpolation (${VAR_NAME}) keeps secrets out of the committed file. Each developer sets the actual values in their local environment (via .env.local, a secrets manager, or shell profile), and the settings file only contains the variable names. This is the same pattern used by CI systems — the config is version-controlled, the secrets are not.

For global servers you want available in every project (GitHub, for instance), use claude mcp add --global to write to your user-level Claude Code config instead of the project file. Global servers are always available but cannot be shared with teammates — each person sets them up individually.

Which MCP Servers Should You Add First?

Not every project needs every server. The right set depends on your stack and workflow. Here is a practical recommendation hierarchy:

Start with these for any project: GitHub MCP is nearly universal — almost every project has a repository. Add it first. Filesystem MCP is often already configured but worth explicitly scoping to your source directory if you are in a monorepo. AppHandoff MCP is worth adding early if you are working with multiple agents or want API contract tracking — the mismatch detection alone pays for the setup time in teams where frontend and backend are developed independently.

Add based on your stack: PostgreSQL or Supabase MCP if you have a relational database (Supabase MCP if your backend is Supabase; PostgreSQL MCP for any other Postgres instance). Linear MCP if your team uses Linear for issue tracking. The time spent giving Claude Code access to your actual tickets pays back immediately on any non-trivial implementation task.

Add for specific workflows: Playwright MCP for projects with end-to-end tests or UI verification requirements. It is overkill for pure library or CLI projects, but highly valuable for any web application where visual correctness matters.

For a broader survey of what is available across the MCP ecosystem, see our MCP server examples guide. For the technical architecture of how MCP servers work under the hood, the MCP developer guide covers transport, sessions, and tool discovery in depth.

Getting the Most Out of MCP in Claude Code

Adding MCP servers is the first step. Getting the most out of them requires a few additional practices. First, be explicit in your prompts about when to use MCP context — instead of "fix the bug", try "check the GitHub issue #123 for the full description, then fix the bug". Claude Code will use MCP tools opportunistically, but explicit references ensure it uses them for the right tasks.

Second, use scoped filesystem access in monorepos. Giving Claude Code access to the entire repo when it only needs packages/api/src floods the context with irrelevant files and slows down directory listings. Narrower access means faster, more accurate responses.

Third, treat your MCP configuration as code. Commit .claude/settings.json to your repository, document which servers are required and how to get the necessary API keys, and keep the configuration in sync as your stack evolves. New team members (and new agent sessions) should be able to get a fully-configured Claude Code setup from a single git clone plus a secrets injection step.

The combination of the right MCP servers transforms Claude Code from a capable code editor into a project-aware development partner that understands your full context — your tickets, your schema, your contracts, your test results. That is the shift from guesswork to ground truth that makes AI-assisted development actually reliable at scale.