Best MCP Servers for Claude Code (Tested, 2026)

Every MCP server you add costs context. The tool definitions load at session start whether you use them or not, so a bloated config makes Claude slower and less accurate. These are the servers that earn their place, with the exact config for each.

Quick Answer: The MCP servers most worth adding to Claude Code are filesystem, github, postgres, playwright, and fetch. Add them to ~/.claude.json under mcpServers. Pair each with a SKILL.md skill that tells Claude how to use it, or you get tool access without judgement.

Filesystem: scoped file access outside your project

Claude Code already reads your working directory. The filesystem server matters when you need access to a directory outside it, a shared design folder, a sibling repo, a notes vault.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/you/projects/shared",
        "/Users/you/Documents/specs"
      ]
    }
  }
}

Every path you list is granted. Every path you don't is denied. List directories explicitly rather than pointing at your home folder.

Why this earns its slot: it's the only server here that changes what Claude can see rather than what it can do.

Recommended skills

skill-router-2

by Shippers · 5

Automatically detect, load, and stack the perfect skills combo for any user requ…

$5

Solo SaaS Architect

by tudor.ai

Automatically builds complete, launch-ready SaaS websites, databases, and secure…

$5

env-doctor

by Samuel Rose · 155

Diagnoses why your project will not start. Checks runtime versions, dependencies…

Free

Browse all Claude Code skills

GitHub: issues, PRs, and code review without leaving the terminal

Reads issues, opens PRs, posts review comments, and searches across repos you have access to.

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token"
      }
    }
  }
}

Use a fine-grained token scoped to specific repos. A classic token with full repo scope gives Claude write access to everything you can touch.

Pair it with pr-description-writer (85 installs, free) so Claude writes the PR body in a consistent format instead of improvising, and code-reviewer (764 installs, free) so review comments follow a severity structure.

Why this earns its slot: it closes the loop between writing code and shipping it.

Postgres: query your actual schema instead of guessing

Without database access, Claude infers your schema from migration files and gets it wrong when migrations have drifted from production.

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://readonly_user@localhost/mydb"
      ]
    }
  }
}

Connect with a read-only role. There is no reason for a coding agent to hold write credentials to a database, and a read-only role turns a bad instruction into a failed query rather than a dropped table.

Why this earns its slot: it replaces a guess with a fact.

Playwright: let Claude see what it built

Claude writes frontend code blind unless it can load the page. Playwright gives it a browser: navigate, screenshot, click, fill forms, read console errors.

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest"]
    }
  }
}

The workflow that makes this worth it: Claude writes a component, loads it, screenshots it, notices the layout is broken, fixes it. Without the browser, that loop needs you in it.

Why this earns its slot: it turns frontend work from open-loop into closed-loop.

Fetch: read documentation and APIs directly

Retrieves a URL and converts it to markdown. Useful when you need Claude working against current docs rather than whatever it remembers.

{
  "mcpServers": {
    "fetch": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-fetch"]
    }
  }
}

Why this earns its slot: it's the cheapest way to stop Claude inventing API signatures.

What to skip

Servers that duplicate something Claude Code already does natively. It runs shell commands, reads and writes files in your project, and handles git without help. A server that wraps git adds tool definitions and removes nothing.

Servers for tools you touch monthly. Every definition loads every session. A Jira server you use twice a quarter costs you context in 88 sessions to save time in 2.

Why MCP servers need skills

An MCP server gives Claude a capability. It does not give Claude judgement about when or how to use it.

With a Postgres server and no skill, "check the users table" produces whatever query Claude improvises. With a skill defining your conventions, always LIMIT, never SELECT *, check indexes before suggesting a query, you get the same capability applied consistently.

The pattern: MCP servers are the hands, skills are the method. Browse skills for Claude Code on Agensi.

Setting up your config

1. Open ~/.claude.json, or create it if it doesn't exist
2. Add an mcpServers object with the servers above
3. Put tokens in env, never inline in args
4. Restart your Claude Code session
5. Run /mcp to confirm each server connected

If a server fails to appear, the MCP Inspector will tell you why before you start guessing.

For more on how servers and skills work together, read How MCP Servers and SKILL.md Skills Work Together.