What is MCP (Model Context Protocol) and How Does It Extend Claude's Capabilities?

Mar 22, 2026

Problem

I kept seeing “MCP” mentioned in AI discussions, but nobody explained it clearly. Reddit users said things like “MCP enables Claude to interact with other applications” or “MCPs are just servers that hold tools.” These explanations were technically correct but didn’t help me understand what MCP actually is or why I should care.

I wanted to connect Claude to my tools - my databases, my files, my APIs. But every integration seemed to require custom code. Was MCP the solution? I didn’t know because every explanation assumed I already understood the concept.

What is MCP?

After reading the official documentation and testing it myself, I found a simple analogy that clicked: MCP is like USB-C for AI applications.

Before USB-C, you needed different cables for different devices. One for your phone, another for your camera, yet another for your hard drive. USB-C standardized everything: one port, one cable type, works everywhere.

MCP does the same for AI. Instead of building custom integrations for every tool and data source, developers build one MCP server that works with any MCP-compatible AI client:

Claude Desktop
Claude Code
ChatGPT
VS Code (with Copilot)
Cursor

One server, multiple AI clients. That’s the power of MCP.

How MCP Works

MCP uses a simple three-part architecture:

┌─────────────────────────────────────────────────────────────┐
│                    MCP Host (AI Application)                │
│              Claude Desktop / Claude Code / VS Code         │
└─────────────────────────────────────────────────────────────┘
                              │
           ┌──────────────────┼──────────────────┐
           │                  │                  │
           ▼                  ▼                  ▼
    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
    │ MCP Client  │    │ MCP Client  │    │ MCP Client  │
    │    (1)      │    │    (2)      │    │    (3)      │
    └─────────────┘    └─────────────┘    └─────────────┘
           │                  │                  │
           ▼                  ▼                  ▼
    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
    │ Filesystem  │    │ PostgreSQL  │    │   GitHub    │
    │   Server    │    │   Server    │    │   Server    │
    │   (local)   │    │   (local)   │    │  (remote)   │
    └─────────────┘    └─────────────┘    └─────────────┘

MCP Host: The AI application you’re using. It coordinates all connections.

MCP Client: Each connection to an MCP server gets its own client object that manages communication.

MCP Server: A program that provides tools, data, or prompts. Examples:

Filesystem server: Lets AI read/write files
Database server: Lets AI query PostgreSQL
GitHub server: Lets AI create issues, review PRs

What Can MCP Servers Provide?

MCP servers expose three types of capabilities:

1. Tools (Executable Functions)

Functions the AI can call to perform actions:

Tool	What It Does
`query_database(sql)`	Run SQL queries
`send_message(to, text)`	Send Telegram messages
`get_weather(location)`	Fetch weather data
`read_file(path)`	Read file contents

2. Resources (Data Sources)

Context that the AI can read:

Database schemas
File contents
API responses
Configuration files

3. Prompts (Templates)

Pre-written interaction templates:

Code review templates
Documentation generators
Analysis frameworks

Real MCP Server Examples

I tested several official reference servers that are ready to use:

Server	What It Does	How to Run
Filesystem	Read/write files on your computer	`npx -y @modelcontextprotocol/server-filesystem /path`
Git	Search and manipulate git repositories	`uvx mcp-server-git`
GitHub	Create issues, review PRs, manage repos	`npx -y @modelcontextprotocol/server-github`
Memory	Knowledge graph for persistent memory	`npx -y @modelcontextprotocol/server-memory`
Fetch	Get web content for AI processing	`npx -y @modelcontextprotocol/server-fetch`
Time	Timezone conversion capabilities	`uvx mcp-server-time`

Community servers include PostgreSQL, Slack, Discord, Google Drive, Notion, and hundreds more.

How to Connect MCP Servers to Claude

I configured my Claude Desktop to use multiple MCP servers. Here’s my configuration:

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

After adding this configuration, I restarted Claude Desktop. Now when I ask Claude to “read the main.py file in my project,” it can actually do it through the filesystem server.

Building Your Own MCP Server

I built a simple MCP server to understand how it works. Here’s a minimal Python example that exposes a get_current_time tool:

from mcp.server import Server
from mcp.types import Tool, TextContent
import mcp.server.stdio
from datetime import datetime

server = Server("time-server")

@server.list_tools()
async def list_tools():
    return [
        Tool(
            name="get_current_time",
            description="Get the current time in ISO format",
            inputSchema={"type": "object", "properties": {}}
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "get_current_time":
        return [TextContent(type="text", text=datetime.now().isoformat())]
    raise ValueError(f"Unknown tool: {name}")

async def main():
    async with mcp.server.stdio.stdio_server() as (read, write):
        await server.run(read, write)

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

To test this server:

# Install the MCP SDK
pip install mcp

# Run the server
python time_server.py

I used the MCP Inspector to test it:

npx @modelcontextprotocol/inspector python time_server.py

The Inspector opened a web interface where I could see my get_current_time tool and test it.

Why MCP Matters for Developers

Build Once, Use Everywhere

Write one MCP server and it works with Claude, ChatGPT, VS Code, Cursor - any MCP client. No need to build separate integrations for each AI platform.

Standardized Protocol

MCP is built on JSON-RPC 2.0, which means:

Capability negotiation during initialization
Real-time notifications when tools change
Support for both local (stdio) and remote (HTTP) servers

Security by Design

Local servers run with user permissions
Remote servers use OAuth/API key authentication
Tools require explicit user approval in most clients

The Reason MCP Works

I found that Reddit users explained it well:

“Think of it like a roundabout - data can come in from one platform and go into another.” - Reddit user

This is exactly right. Claude can pull data from my Google Calendar, process it, and send results to Telegram - all through standardized MCP connections.

Another user put it simply:

“MCP lets you connect Claude to other tools like databases or APIs so it can do more without you explaining everything.”

Before MCP, if I wanted Claude to query my database, I had to:

Export the data
Copy it into the chat
Ask Claude to analyze it

With MCP, Claude can query my database directly. No copy-paste needed.

Common Mistakes

When I first tried MCP, I made these mistakes:

Mistake 1: Not restarting Claude Desktop after config changes

The configuration file is only read at startup. After editing, restart the app.

Mistake 2: Using wrong paths in filesystem server

// WRONG: Relative path
"args": ["-y", "@modelcontextprotocol/server-filesystem", "./projects"]

// CORRECT: Absolute path
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/cowrie/projects"]

Mistake 3: Forgetting to set environment variables

The GitHub server needs a token. Without it, the server starts but can’t access your repos.

Mistake 4: Installing servers globally

Use npx -y to run servers directly without installing them globally. This keeps your system clean.

Summary

In this post, I explained MCP (Model Context Protocol) in simple terms. The key points are:

MCP is like USB-C for AI - one standard connection that works everywhere
Servers provide Tools (functions), Resources (data), and Prompts (templates)
Configuration is simple JSON in a config file
You can build custom servers in Python or TypeScript

When I understood that MCP is a standardization layer, not a new technology to learn, everything clicked. It’s not about learning a new API - it’s about using one protocol instead of many.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!