What is the Model Context Protocol?

Claude Code comes with powerful built-in tools — reading and writing files, executing commands, searching code. But real-world development goes far beyond that: you need to check GitHub Issues, send Slack messages, query databases, operate browsers, access Jira boards…

Model Context Protocol (MCP) is an open protocol designed to solve this problem. It defines a standardized way for AI applications to connect to external services and data sources. Think of MCP as the USB port of the AI world — any device that follows the protocol can plug and play.

MCP Architecture

MCP uses a client-server architecture:

• Host: Claude Code itself, responsible for managing multiple MCP clients
• Client: Created by the Host, maintains a one-to-one connection with a single MCP Server
• Server: Independent process that connects to an external service and exposes capabilities to the Client

Three Capabilities Exposed by MCP Servers

Each MCP Server can provide three types of capabilities to the AI:

1. Tools

Functions the AI can call. For example, a GitHub MCP Server might provide create_issue, list_pull_requests, and merge_pr tools. Claude can call them just like built-in tools.

2. Resources

Data the AI can read. Similar to REST API GET endpoints. For example, a database MCP Server might expose table schemas as resources, letting Claude directly read schema information.

3. Prompts

Predefined interaction templates. Servers can provide prompt templates for specific scenarios, helping users interact with the AI more effectively.

How to Configure MCP Servers

Configuring MCP Servers in Claude Code is straightforward. Add the following to your project’s .claude/settings.json:

{
"mcpServers": {
  "github": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-github"],
    "env": {
      "GITHUB_TOKEN": "ghp_xxxxxxxxxxxx"
    }
  },
  "postgres": {
    "command": "npx",
    "args": [
      "-y",
      "@modelcontextprotocol/server-postgres",
      "postgresql://localhost:5432/mydb"
    ]
  },
  "playwright": {
    "command": "npx",
    "args": ["-y", "@playwright/mcp@latest"]
  }
}
}

Each Server configuration contains:

• command: The command to start the Server
• args: Command-line arguments
• env (optional): Environment variables for passing API keys, etc.

Transport Protocols

MCP supports two transport methods:

stdio (Standard I/O)

Used for local processes. The Host directly spawns the Server process and communicates via stdin/stdout. This is the most common approach — the Server runs as a child process with no network configuration needed.

Host                    Server (child process)
│                         │
│── JSON-RPC via stdin ──▶│
│◀── JSON-RPC via stdout ─│
│                         │
│  (stderr used for logs)  │

SSE (Server-Sent Events)

Used for remote servers. Connects to a remote MCP Server via HTTP, suitable for team-shared services or cloud-deployed tools.

{
"remote-server": {
  "url": "https://mcp.example.com/sse",
  "headers": {
    "Authorization": "Bearer token_xxx"
  }
}
}

JSON-RPC: The Underlying Protocol

MCP communication is based on the JSON-RPC 2.0 protocol. Every tool call is a standard JSON-RPC request/response pair:

// Client → Server: Call tool
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
  "name": "create_issue",
  "arguments": {
    "repo": "user/project",
    "title": "Fix login bug",
    "body": "The login form crashes on submit..."
  }
}
}

// Server → Client: Return result
{
"jsonrpc": "2.0",
"id": 1,
"result": {
  "content": [
    {
      "type": "text",
      "text": "Created issue #42: Fix login bug"
    }
  ]
}
}

Popular MCP Servers

The MCP ecosystem already has a large number of available Servers:

• GitHub: Manage Issues, PRs, code reviews
• Slack: Send messages, browse channels, manage workflows
• PostgreSQL / MySQL: Query databases, manage table schemas
• Playwright: Control browsers, take screenshots, automate testing
• Filesystem: Sandboxed file system access
• Sentry: View error reports and performance data
• Linear / Jira: Project management and task tracking

MCP vs Built-in Tools

You might ask: why not make everything built-in?

• Built-in tools: Developed and maintained by the Claude Code team. Limited in number but deeply integrated. Includes core dev tools like Read, Edit, Bash, and Grep.
• MCP tools: Anyone can write an MCP Server. The ecosystem is open and extensible. You can write an MCP Server for your company’s internal systems and let Claude Code operate them directly.

The core value of MCP is extensibility. It transforms Claude Code from a fixed-function tool into a platform that can connect to any service. Every new MCP Server expands the boundaries of Claude’s capabilities.

Security Considerations

MCP Servers run in independent processes, and Claude Code’s permission system applies equally to MCP tool calls. Sensitive operations (like writing to a database or sending messages) prompt for user confirmation before execution. API keys are passed via environment variables and never appear in the conversation context.