MCP — Model Context Protocol

What is MCP?

The Model Context Protocol (MCP) is an open standard published by Anthropic in November 2024 that gives AI assistants a standardised way to connect to external data sources and tools.

Before MCP, every AI integration was custom-built. If you wanted Claude to read your database, someone had to write bespoke code to connect the two — and that code only worked with Claude. If you switched to a different AI tool, you started from scratch.

MCP is like USB-C for AI: one standard connector that works everywhere. An MCP server written for your database works with Claude Desktop, Claude Code, Cursor, and any other MCP-compatible client. Write it once, use it anywhere.

Why it matters

Without MCP, Claude only knows what you paste into the chat. With MCP, Claude can work with your actual data — in real time, in its native location.

The difference in practice:

• Instead of copying a SQL query result and pasting it into Claude, Claude can run the query itself
• Instead of exporting GitHub issues to a doc, Claude can read and comment on them directly
• Instead of downloading files and uploading them, Claude can read your local filesystem
• Instead of screenshotting Slack threads, Claude can search them directly

The AI goes from "answering questions about things you paste" to "working with your actual systems."

How it works

You → Claude Desktop / Claude Code
         ↓
    MCP Client (built into Claude)
         ↓
    MCP Server (small program you install)
         ↓
    Your Data (filesystem / GitHub / database / Slack / etc.)

Each MCP server is a small, focused program that knows how to talk to one specific data source. You install the server, tell Claude where to find it, and from that point Claude can use the tools that server exposes — searching files, running queries, creating issues, whatever the server supports.

Popular MCP servers

Step-by-step: add your first MCP server (Filesystem)

The filesystem server lets Claude read and write files anywhere on your computer — not just inside a project directory.

1. Find the Claude Desktop config file

• Mac: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

2. Edit the config file

Open it in any text editor and add the filesystem server. Replace /Users/yourname/Documents with the folder you want Claude to access:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/yourname/Documents"
      ]
    }
  }
}

3. Restart Claude Desktop

Quit and reopen the Claude desktop app. You should see a hammer icon (🔨) in the chat input — that means MCP tools are available.

4. Test it

Ask Claude: "What files are in my Documents folder?" Claude will list them without you having to paste anything.

Tip: You can add multiple paths by adding more arguments to the args array. You can also add multiple MCP servers by adding more entries under mcpServers.

Step-by-step: add GitHub MCP

1. Create a GitHub personal access token

• Go to github.com → Settings → Developer settings → Personal access tokens → Tokens (classic)
• Generate a new token with these scopes: repo, read:org, read:user
• Copy the token (you won't see it again)

2. Update your config

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

3. Restart and test

Ask Claude: "List the open issues in my repository [owner/repo]" or "Show me the last 5 pull requests."

Using MCP with Claude Code

Claude Code supports MCP natively. You can add servers globally (for all projects) or per-project.

Add a server globally:

claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /Users/yourname

Add a server to a specific project (creates .claude/mcp.json):

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

Claude Code will use the server's tools automatically during any session where it's relevant.

Finding more MCP servers

The MCP ecosystem is growing fast. Good places to find servers:

• modelcontextprotocol.io/servers — the official directory
• mcp.so — community-curated directory with ratings
• GitHub — search "awesome-mcp-servers" for curated lists
• npm — search @modelcontextprotocol for official servers

Building your own MCP server

If you have an internal database, API, or tool that isn't covered by community servers, you can build a custom MCP server using the official SDKs in Python or TypeScript.

Building a basic server takes a few hours of developer time. Once built, your entire team benefits. The official docs at modelcontextprotocol.io have quickstart guides for both languages.

This is worth doing if you have a proprietary internal system — a CRM, an internal knowledge base, a custom database — that you'd like Claude to be able to query.

Security

Only install MCP servers from sources you trust. An MCP server runs on your machine with the permissions you grant it. A malicious server could read files or access systems you didn't intend.

Practical rules:

• Stick to official servers from @modelcontextprotocol on npm for sensitive systems
• Use fine-grained access tokens (read-only where possible) for services like GitHub
• Don't put your claude_desktop_config.json in a public repository — it contains your API keys
• Review what file paths and permissions you're granting before adding a new server