Best MCP Servers for Claude Code in 2026

The most useful MCP servers for Claude Code: GitHub, Brave Search, PostgreSQL, Notion, Slack, and more. Setup commands, use cases, and what to do when MCP isn't enough.

by AnyCap

Most Claude Code users start with the default setup. Then they hit the first wall: the agent needs to pull a GitHub issue, query the production database, or check what changed in a dependency — and it can't.

That's the MCP problem. Here's the solution: the MCP servers Claude Code teams actually keep installed, with setup config and honest notes on what each one does well.

What MCP Servers Do for Claude Code

MCP (Model Context Protocol) is the standard that lets Claude Code connect to external tools through a consistent interface. When you add an MCP server, Claude discovers its tools automatically and can call them during agent sessions without you manually pasting in data.

Add the right servers and Claude Code becomes a genuinely different tool — one that can read your repo, query your database, search the web, and cross-reference your internal docs without you acting as the middleman.

The Best MCP Servers for Claude Code

1. GitHub — For Repo-Aware Coding Sessions

The most universally useful server for developers. Claude Code gains direct access to your GitHub repositories without you needing to paste PR descriptions, issue text, or file diffs manually.

Setup:

claude mcp add github -- npx -y @modelcontextprotocol/server-github

Set GITHUB_TOKEN as an environment variable (generate a fine-grained personal access token from GitHub Settings → Developer Settings).

What it unlocks:

  • Fetch open pull requests and their diffs
  • Read issue descriptions and comments
  • List and read files from any repo you have access to
  • Create or update issues during a coding session

Best for: Any team using GitHub for code review, project management, or documentation.

2. Brave Search — For Up-to-Date Technical Research

Claude's training data has a cutoff. Brave Search gives it real-time access to the web — current docs, recent Stack Overflow answers, changelog entries, security advisories.

Setup:

claude mcp add brave-search -- npx -y @modelcontextprotocol/server-brave-search

Requires a Brave Search API key (free tier available at api.search.brave.com).

Set BRAVE_API_KEY in your environment.

What it unlocks:

  • Search for current library documentation
  • Find recent error messages and their solutions
  • Check what changed in a package's latest release
  • Fetch news and announcements relevant to the task

Best for: Any session where training-data freshness matters — framework migrations, security research, evaluating new dependencies.

3. PostgreSQL — For Database-Aware Development

Writing migration scripts, debugging slow queries, or building features against your schema? This server gives Claude Code read access to your actual database structure and data.

Setup:

claude mcp add postgres -- npx -y @modelcontextprotocol/server-postgres postgresql://user:password@localhost/dbname

What it unlocks:

  • Inspect table schemas and relationships
  • Run SELECT queries to validate assumptions
  • Analyze existing data patterns before writing migrations
  • Explain slow queries against real data

Best for: Backend development, data modeling, migration work, query optimization.

Security note: Use a read-only database user. Claude Code should never have write access to production data through an MCP server.

4. SQLite — For Lightweight Local Database Access

The same capability as PostgreSQL but for SQLite databases — local development databases, embedded databases in mobile apps, or test fixtures.

Setup:

claude mcp add sqlite -- npx -y @modelcontextprotocol/server-sqlite /path/to/database.db

No connection string needed — just the path to the .db file.

Best for: Local development environments, mobile app development, prototype data exploration.

5. Filesystem — For Expanded File Access

By default, Claude Code works within your project directory. The filesystem server extends that access to any directory you specify — config directories, reference projects, documentation, shared assets.

Setup:

claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/directory

You can specify multiple allowed directories.

What it unlocks:

  • Read config files outside the project root
  • Reference code from other local projects
  • Access documentation or asset libraries stored elsewhere

Best for: Teams with monorepos, cross-project references, or documentation stored outside the main codebase.

6. Notion — For Spec and Documentation Access

Product specs, design documents, meeting notes, architecture decisions — if your team stores knowledge in Notion, this server makes it directly accessible to Claude Code during sessions.

Setup:

claude mcp add notion -- npx -y @modelcontextprotocol/server-notion

Requires a Notion integration token (create at notion.so/my-integrations).

Set NOTION_API_TOKEN in your environment.

What it unlocks:

  • Read product requirements before implementing features
  • Pull in acceptance criteria from Notion tickets
  • Reference architecture decisions during code review
  • Access team runbooks while debugging

Best for: Teams that use Notion as their primary knowledge base and want Claude Code to have context from it without manual copy-paste.

7. Slack — For Team Context During Development

When the right answer to "why does this code work this way?" lives in a Slack thread from six months ago, this server gives Claude Code access to that history.

Setup:

claude mcp add slack -- npx -y @modelcontextprotocol/server-slack

Requires a Slack bot token with appropriate scopes.

Set SLACK_BOT_TOKEN and SLACK_TEAM_ID in your environment.

What it unlocks:

  • Search message history for context on implementation decisions
  • Read recent thread discussions relevant to the task
  • Post updates or questions to channels during longer agent sessions

Best for: Teams where important technical context lives in Slack threads rather than documentation.

8. Memory — For Persistent Agent Context

The memory server gives Claude Code the ability to store and retrieve information across sessions. Useful for tracking project-specific conventions, user preferences, or long-running state.

Setup:

claude mcp add memory -- npx -y @modelcontextprotocol/server-memory

No API key required — uses local storage.

What it unlocks:

  • Remember project-specific conventions between sessions
  • Store and retrieve decisions made in previous coding sessions
  • Build a lightweight knowledge base the agent can reference

Best for: Long-running projects where continuity between sessions matters.

Team-Wide Config with .mcp.json

Rather than configuring servers individually on each machine, commit a .mcp.json file to your project root:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": { "BRAVE_API_KEY": "${BRAVE_API_KEY}" }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "${DATABASE_URL}"]
    },
    "notion": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-notion"],
      "env": { "NOTION_API_TOKEN": "${NOTION_API_TOKEN}" }
    }
  }
}

Use environment variable references (${VAR_NAME}) and keep actual credentials in .env or your secrets manager. Add .mcp.json to .gitignore if it contains credentials directly.

What MCP Servers Don't Cover

The eight servers above handle internal integrations well. Where they fall short is the common capabilities most agent workflows eventually need:

Image generation — no stable MCP server provides multi-model image generation with quality model selection.

Video generation — essentially uncovered in the MCP server ecosystem.

Cloud file storage + public URLs — MCP servers handle specific services (S3, GCS), but there's no unified interface for upload → share link.

Web page publishing — not part of the standard MCP server catalog.

For these, the approach most teams use is a capability runtime alongside their MCP servers:

# With AnyCap installed
anycap image generate "product mockup for landing page"
anycap video generate "30s feature demo"
anycap drive upload ./build/
anycap page publish ./dist/

One CLI, one auth flow, no additional tool-schema tokens. The agent handles media and publishing without a separate MCP server for each capability.

More on when to use which approach: MCP Servers vs Capability Runtimes →

Token Cost Reality Check

Adding multiple servers has a cost. Each server registers its tool schemas in Claude's context window:

Servers Estimated context overhead
2 servers ~6,000–16,000 tokens
4 servers ~12,000–32,000 tokens
6 servers ~18,000–48,000 tokens

On Claude's 200K context window, six servers can consume up to 24% of available context before a single line of your code or conversation history is added.

Practical guideline: configure the servers you actually use regularly, not the ones you might use someday. You can always add and remove servers as projects change.

Quick Troubleshooting

# See what's connected
claude mcp list

# Diagnose connection issues
claude doctor

# Remove a server
claude mcp remove <server-name>

# Verify tools are loading
# (Ask Claude directly: "What tools do you have available?")

Common fixes:

  • Server not appearing: Quit and fully restart Claude Code
  • Connection errors: Check Node.js version (nvm use 22 resolves most issues)
  • Auth failures: Regenerate the API key; verify env variable name matches exactly

FAQ

How many MCP servers should I add?

Start with two or three that address your immediate workflow gaps. Add more as you identify specific needs. More than five servers becomes hard to maintain and starts to meaningfully consume context tokens.

Do I need different servers for different projects?

Yes — use .mcp.json per project to configure only the servers relevant to that codebase. A database server for a backend project doesn't belong in a frontend project config.

What's the difference between claude mcp add and .mcp.json?

claude mcp add configures servers globally for your user account. .mcp.json in a project root configures servers for that project only, and applies to anyone who opens the project. For team use, .mcp.json is the right approach.

Are there MCP servers for image or video generation?

A few experimental options exist, but none have the model breadth or reliability of dedicated media generation platforms. Teams that need media generation in Claude Code workflows typically use a capability runtime.