Claude Code MCP Servers Guide: Complete Setup Walkthrough (2026)

The Short Answer

MCP servers are local or remote processes that expose tools, resources, and prompts to Claude Code over a JSON-RPC protocol. Add one with claude mcp add, pick the right scope and transport, and Claude Code gains the ability to read and act on that system directly.

What MCP Servers Actually Do

The Model Context Protocol is an open standard from Anthropic for AI-tool integrations. Without MCP, Claude Code only sees what you paste into chat. With MCP, it reaches into GitHub, databases, monitoring dashboards, design files, and internal APIs the same way a senior engineer would.

Connect a server the moment you catch yourself copying something from another tool into a Claude Code prompt. That copy-paste friction is the exact signal an MCP integration will pay off.

Real Tasks MCP Unlocks

• ●Implement tickets end-to-end. "Build the feature described in ENG-4521 and open a PR on GitHub." One prompt, two MCP servers, full delivery loop.
• ●Query production data. "Find emails of 10 random users who used feature ENG-4521, based on our Postgres database." No SQL copy-paste.
• ●Integrate designs automatically. "Update the email template based on the new Figma designs posted in Slack." Pull designs, edit code, open PR.
• ●React to external events. MCP servers can act as channels that push messages into your session, so Claude reacts to Telegram pings, Discord chats, or webhook events while you are away.

Three Ways to Install: Transports Compared

Every MCP server uses one of three transport protocols. Pick the wrong one and the server either cannot reach your system or cannot reach the internet. Here is the decision matrix.

Install Commands by Transport

Three Scopes: Local, Project, User

Scope controls where the MCP configuration is stored and who can see it. The default is local, which is almost never what you want for long-lived tools.

Step-by-Step: Connect GitHub to Claude Code

GitHub is the most useful first MCP server. It lets Claude Code open PRs, read issues, search code across repos, and review changes. Here is the complete install path.

The .mcp.json File Explained

When you add a project-scoped server, Claude Code writes to a file called .mcp.json at the repo root. Commit it to git and every teammate gets the same setup automatically.

Minimal Example

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "postgres": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    },
    "sentry": {
      "type": "http",
      "url": "https://mcp.sentry.dev/mcp"
    }
  }
}

Use ${ENV_VAR} interpolation for secrets so teammates supply their own keys. Never hardcode tokens in .mcp.json-- the file is committed to git.

Config File Locations

Tool Search: Why 2026 Changed the Context Game

Every MCP server you add used to bloat the system prompt. A single GitHub MCP alone exposed ~80 tools, each with schemas and descriptions. Load 5 servers and you burned 30,000+ tokens before the first user message.

Tool Search fixes this. Claude Code indexes every tool from every connected server and only loads the definitions that match the current task. Independent measurements put the context reduction at 85-95% compared to clients that dump every tool definition upfront.

What This Unlocks

• ●Install everything. 10-15 MCP servers no longer cost tokens on every request. Connect the full stack.
• ●Better model focus. Fewer irrelevant tools in context means the model picks the right action more reliably.
• ●Faster sessions. Smaller prompts = smaller latency = snappier iteration loops.

10 Best MCP Servers for Claude Code in 2026

The MCP registry has hundreds of servers. These ten cover 90% of what an engineer actually needs day-to-day. Install them with user scope unless otherwise noted.

Security: Audit Before You Install

MCP servers run code. Anthropic explicitly warns that it has not verified third-party servers. Treat every community server with the same scrutiny you give any npm dependency -- maybe more, because the model calls it autonomously.

Prompt injection is the biggest real-world risk. If an MCP server fetches web pages, emails, or Slack messages, attacker content inside those payloads can instruct Claude Code to exfiltrate data via other tools. Sandbox anything that reads untrusted text.

Managing and Debugging MCP Servers

Three shell commands and one in-session slash command cover everything you will need.

Useful Environment Variables

• ●MCP_TIMEOUT -- Server startup timeout in ms. Raise to 10000 for slow stdio servers.
• ●MAX_MCP_OUTPUT_TOKENS -- Cap on tool output. Defaults to 10,000; raise to 50,000 for tools that return large payloads.

Plugin-Provided MCP Servers

Claude Code plugins can bundle their own MCP servers. When the plugin is enabled the servers start automatically -- no claude mcp add required.

Plugin MCP Config Example

{
  "mcpServers": {
    "database-tools": {
      "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",
      "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"],
      "env": {
        "DB_URL": "${DB_URL}"
      }
    }
  }
}

Put this either in .mcp.json at the plugin root or inline under an mcpServers block in plugin.json. The ${CLAUDE_PLUGIN_ROOT} variable resolves to the plugin install path at runtime.

Common Mistakes That Break MCP Servers

Most MCP problems come down to five recurring mistakes. Fix these before opening a support issue.

• ●Flags after the server name. All options (--transport, --env, --scope, --header) must come before the server name. The -- separator matters.
• ●Windows without cmd /c. On native Windows (not WSL), stdio servers using npx require the cmd /c wrapper. Without it you get "Connection closed" errors.
• ●Wrong scope for team tools. Adding a shared GitHub server with local scope means only you see it. Use project scope so .mcp.json ends up in git.
• ●Hardcoded secrets. Never paste raw tokens into .mcp.json. Use ${ENV_VAR} interpolation and commit a sanitized version.
• ●Ignoring SSE deprecation. New code should never depend on SSE transport. If the provider only offers SSE, push them to ship HTTP, or wait.

Frequently Asked Questions

Bottom Line

MCP servers are the difference between an AI that writes code in a vacuum and one that ships features against your real backlog, database, and monitoring stack.

Install GitHub first. Add Context7, your database, Sentry, and Linear next. Keep secrets out of .mcp.json. Audit before you connect anything unfamiliar. Tool Search will handle the context cost.

The full KaiShips Guide to Claude Code walks through every server in production detail, including our real setup for a one-agent SaaS business shipping code 24/7.

Related Reading