MCP — Model Context Protocol

What is MCP?

Model Context Protocol (MCP) is an open standard developed by Anthropic that defines how AI models communicate with external tools, data sources, and services. It gives AI agents a standardised way to reach beyond their training data — querying live databases, reading files, calling APIs, and executing actions.

Think of MCP as USB for AI. Just as USB standardised how devices connect to computers, MCP standardises how AI agents connect to the world.

Without MCP:

Each AI tool → custom integration → each data source
Claude Desktop needs custom code for GitHub, Jira, Slack, databases... separately

With MCP:

Any MCP-compatible AI tool → MCP protocol → any MCP server
One standard. Write it once, works with Claude, Kiro, Cursor, and any future AI tool.

The Problem MCP Solves

LLMs are powerful but isolated. Out of the box, an AI assistant only knows what’s in its training data and the current conversation. For real-world work, it needs:

Your database schema — to write accurate queries
Your Jira tickets — to implement the right feature
Your codebase — to make consistent changes
Live APIs — to take actions, not just describe them

Before MCP, every AI tool built its own proprietary integration for each data source. The result: fragmented tooling, no reuse, constant duplication.

MCP introduces one protocol, enabling a marketplace of reusable servers that work with any compliant AI client.

Architecture

MCP has three roles:

┌─────────────┐     MCP Protocol      ┌─────────────┐     ┌──────────────┐
│  MCP Host   │ ◄──────────────────► │  MCP Client  │ ──► │  MCP Server  │
│             │                       │  (embedded)  │     │              │
│ Claude      │                       │              │     │ GitHub       │
│ Kiro        │                       │              │     │ Jira         │
│ Cursor      │                       │              │     │ SQL Server   │
└─────────────┘                       └─────────────┘     └──────────────┘

MCP Host — the AI application the user interacts with (Claude Desktop, Kiro, Cursor)
MCP Client — the protocol client built into the host, manages connections to servers
MCP Server — a lightweight process that exposes capabilities (tools, resources, prompts) from a specific data source or API

What MCP Servers Expose

Tools

Functions the AI can call to perform actions:

{
  "name": "create_issue",
  "description": "Create a new GitHub issue",
  "parameters": {
    "title": { "type": "string" },
    "body": { "type": "string" },
    "labels": { "type": "array" }
  }
}

Resources

Data the AI can read for context:

github://repos/myorg/myrepo/contents/README.md
jira://projects/PROJ/issues/PROJ-42
file:///home/user/project/schema.sql

Prompts

Pre-built prompt templates the AI can invoke:

"code-review" — structured code review prompt
"bug-report" — extract a structured bug report from a description

MCP Transport

MCP servers communicate via two transport mechanisms:

stdio — the host launches the server as a subprocess, communicating via stdin/stdout. Most common for local tools:

{
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-github"],
  "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
}

HTTP + SSE — for remote servers. The AI connects to an HTTP endpoint. Used for hosted services:

{
  "url": "https://mcp.yourservice.com/sse",
  "headers": { "Authorization": "Bearer ${API_TOKEN}" }
}

Popular MCP Servers

Server	What it provides	Package
GitHub	Issues, PRs, repos, files	`@modelcontextprotocol/server-github`
GitLab	MRs, pipelines, issues	`@modelcontextprotocol/server-gitlab`
Atlassian	Jira tickets, Confluence pages	`@atlassian/mcp-atlassian`
SQL Server	Database schema, queries	`mcp-server-mssql`
PostgreSQL	Database schema, queries	`@modelcontextprotocol/server-postgres`
Filesystem	Read/write local files	`@modelcontextprotocol/server-filesystem`
Fetch	Web page content	`@modelcontextprotocol/server-fetch`
Slack	Messages, channels	`@modelcontextprotocol/server-slack`
AWS KB Retrieval	AWS Bedrock knowledge bases	`@modelcontextprotocol/server-aws-kb-retrieval`

MCP in Different AI Tools

Tool	MCP Support	Config location
Claude Desktop	✅ Full	`~/Library/Application Support/Claude/claude_desktop_config.json`
AWS Kiro	✅ Full	`.kiro/mcp.json` in project
Cursor	✅ Full	`.cursor/mcp.json` or global settings
Windsurf	✅ Full	Settings → MCP
VS Code (Copilot)	✅ (via extensions)	settings.json

Claude Desktop Configuration

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "your_token" }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/projects"]
    }
  }
}

Writing Your Own MCP Server

The MCP SDK makes it straightforward to build a custom server in Python or TypeScript:

# Python — using the MCP SDK
from mcp.server import Server
from mcp.server.models import InitializationOptions
import mcp.types as types

server = Server("my-custom-server")

@server.list_tools()
async def handle_list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="get_product",
            description="Fetch a product by ID from our internal catalog",
            inputSchema={
                "type": "object",
                "properties": {
                    "product_id": {"type": "string"}
                },
                "required": ["product_id"]
            }
        )
    ]

@server.call_tool()
async def handle_call_tool(name: str, arguments: dict) -> list[types.TextContent]:
    if name == "get_product":
        product = await fetch_product(arguments["product_id"])
        return [types.TextContent(type="text", text=str(product))]

// TypeScript
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({ name: "my-server", version: "1.0.0" });

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [{
    name: "get_order",
    description: "Fetch an order from our system",
    inputSchema: {
      type: "object",
      properties: { orderId: { type: "string" } },
      required: ["orderId"]
    }
  }]
}));

const transport = new StdioServerTransport();
await server.connect(transport);

MCP Security Model

MCP servers run locally by default — credentials go from your machine to the target service, not through the AI provider’s servers
Use environment variable references (${TOKEN}) instead of hardcoding secrets in config files
Add MCP config files to .gitignore if they contain org-specific URLs
Scope tokens to the minimum required permissions — prefer read-only where possible
Review third-party MCP servers before installing — they run code on your machine

MCP vs Function Calling vs RAG

Approach	When to use
MCP	Standardised, reusable tool connections. Cross-tool compatibility. Best for production AI workflows.
Function calling	Ad-hoc tools in a single application. Simpler but proprietary to each provider.
RAG	Searching large document collections. Semantic search over embeddings. Complements MCP.

MCP and RAG are complementary: an MCP server can expose a RAG pipeline as a tool, giving the AI a single interface for both structured queries and semantic search.