MCP Fundamentals

The Model Context Protocol (MCP) is an open standard that defines how AI applications connect to external data sources and tools. Released by Anthropic in November 2024 and donated to the Agentic AI Foundation (Linux Foundation) in December 2025, MCP has become the industry-standard protocol for giving language models access to the real world.

MCP is like USB-C for AI — a single, universal connector that replaces dozens of bespoke integrations. But it is more than a plug-and-play metaphor. MCP is a full client-server protocol built on JSON-RPC 2.0, with lifecycle management, capability negotiation, and typed primitives.

The Host-Client-Server Architecture

MCP uses a three-layer architecture. This is not a simple "client talks to server" model — there is an important intermediary.

Why three layers? The host acts as a security and coordination layer. It ensures each server connection is isolated (a compromised filesystem server cannot access your database server), that user consent is obtained before tool invocations, and that capability negotiation happens cleanly.

Transport Mechanisms

The transport layer defines how JSON-RPC messages travel between client and server.

Why MCP Matters

The Problem It Solves

Before MCP, connecting an AI to external data required custom glue code for every integration — an N-times-M problem:

Industry Adoption

What This Means for You

MCP gives Claude Code:

• Real-time data access — Query production databases, check Sentry errors, pull from GitHub, without copy-pasting
• Automation loops — Chain actions: "Find the bug in Sentry, create a GitHub issue, draft a fix, open a PR"
• Context persistence — MCP connections maintain state across your session
• Cross-tool composability — Combine any set of servers into a full development environment

The Three MCP Primitives

MCP servers expose three types of capabilities, each with a different control model.

Tools (Model-Controlled)

Tools are executable functions that Claude can invoke to perform actions. The model decides whether and when to call them based on conversation context.

Think of tools as the "hands" of the AI — they let it do things.

1{
2  "name": "query_database",
3  "description": "Execute a read-only SQL query against the analytics database",
4  "inputSchema": {
5    "type": "object",
6    "properties": {
7      "query": {
8        "type": "string",
9        "description": "SQL query to execute (SELECT only)"
10      }
11    },
12    "required": ["query"]
13  }
14}

Resources (Application-Controlled)

Resources are data sources that provide context. Unlike tools, they are not actions — they are information. The host decides how to incorporate resource data.

Think of resources as the "eyes" of the AI — they let it see things it could not otherwise access.

Each resource has a unique URI (e.g., file:///project/schema.sql, git://repo/main) and can support subscriptions for real-time updates.

Prompts (User-Controlled)

Prompts are pre-defined message templates that users explicitly select. They are the most "human-in-the-loop" primitive.

Think of prompts as "recipes" — structured workflows that a server author packages for common tasks. In Claude Code, they are accessible via /mcp__servername__promptname commands.

Summary: Who Controls What

Configuring MCP in Claude Code

Adding Servers with the CLI

1# Add a remote HTTP server
2claude mcp add --transport http github https://api.githubcopilot.com/mcp/
3 
4# Add a remote server with auth header
5claude mcp add --transport http sentry https://mcp.sentry.dev/mcp \
6  --header "Authorization: Bearer your-token"
7 
8# Add a local stdio server
9claude mcp add postgres -- npx -y @modelcontextprotocol/server-postgres \
10  "postgresql://user:pass@localhost/mydb"
11 
12# Add with explicit scope
13claude mcp add --transport http notion --scope project https://mcp.notion.com/mcp

Management Commands

1claude mcp list              # List all configured servers
2claude mcp get github        # Get details for a specific server
3claude mcp remove github     # Remove a server
4claude mcp restart           # Restart all MCP servers
5/mcp                         # Check status inside Claude Code

The Three Configuration Scopes

Precedence: Local wins over project, which wins over user.

Configuration File Format

.mcp.json (Project scope):

1{
2  "mcpServers": {
3    "github": {
4      "type": "http",
5      "url": "https://api.githubcopilot.com/mcp/"
6    },
7    "postgres": {
8      "command": "npx",
9      "args": ["-y", "@modelcontextprotocol/server-postgres"],
10      "env": {
11        "DATABASE_URL": "${DATABASE_URL:-postgresql://localhost/mydb}"
12      }
13    }
14  }
15}

Environment Variable Expansion

The .mcp.json file supports environment variable expansion:

• ${VAR} — expands to the value of VAR
• ${VAR:-default} — uses default if VAR is not set

This works in command, args, env, url, and headers fields. Essential for sharing configs without hardcoding secrets.

The Complete Lifecycle

Here is what happens when you ask Claude a question that requires external data:

1. You ask a question that requires external data
2. Claude Code has already connected to your configured MCP servers
3. Claude sees available tools and decides which to call
4. The MCP client sends the request through the appropriate connection
5. The MCP server executes the action and returns results
6. Claude receives results and formulates a response

All of this happens automatically. You just ask in natural language.

Next Steps

Now that you understand MCP fundamentals:

1. Essential MCP Servers → — Install the top 10 servers
2. Building Custom MCPs → — Create your own
3. Workflows & Troubleshooting → — Real-world patterns