What Is MCP? A Beginner’s Guide to the Model Context Protocol

If you have used Claude Desktop, Cursor, or any other AI coding tool in the past year, you have probably seen the letters MCP thrown around. People talk about “running an MCP server” or “connecting MCP to Notion.”

It sounds technical. It is actually quite simple, once you see the shape of it.

This article explains what MCP is, why it exists, and how the pieces fit together. By the end you will understand the protocol well enough to install your first MCP server and connect it to Claude Desktop.

The problem MCP solves

LLMs are smart, but they have no idea what is in your real-world tools. Claude does not know what is in your Notion. ChatGPT cannot read your Linear tickets. Cursor cannot see your Figma files.

Every AI tool that wants to connect to your data has to build its own integration. So Anthropic builds connectors for Claude. OpenAI builds connectors for ChatGPT. Cursor builds connectors for Cursor. Every integration is duplicated across every tool.

flowchart LR
    subgraph before ["Before MCP, every tool builds its own integrations"]
        direction LR
        C1[Claude] --> N1[Notion]
        C1 --> G1[GitHub]
        C1 --> S1[Slack]
        C2[Cursor] --> N2[Notion]
        C2 --> G2[GitHub]
        C2 --> S2[Slack]
        C3[ChatGPT] --> N3[Notion]
        C3 --> G3[GitHub]
        C3 --> S3[Slack]
    end

This is the N×M problem. N AI tools times M data sources equals N×M integrations to build. Painful for tool makers. Worse for data providers.

MCP fixes this by being a shared standard. Anthropic introduced it in late 2024. Now every AI tool speaks the same protocol, and every data source only has to expose itself once.

flowchart LR
    subgraph after ["With MCP, one protocol, everyone speaks it"]
        direction LR
        C1[Claude] --> MCP[MCP]
        C2[Cursor] --> MCP
        C3[ChatGPT] --> MCP
        MCP --> N[Notion server]
        MCP --> G[GitHub server]
        MCP --> S[Slack server]
    end

Now Notion writes one MCP server. Every AI tool can talk to it. N + M, not N × M.

What MCP actually is

MCP stands for Model Context Protocol. It is a specification, a set of rules, for how AI applications and external data sources should talk to each other.

Three things to know:

1. It is open. Anyone can build a client or a server. Published spec, MIT licensed.
2. It is a protocol, not a product. You do not “buy MCP.” You build a client or server that follows the protocol.
3. It was introduced by Anthropic in late 2024, but is now used by Cursor, Continue, Zed, Windsurf, ChatGPT, and many more.

Think of MCP like HTTP for AI tools. HTTP doesn’t do anything itself, it is just rules for how browsers and servers should communicate. MCP is the same idea, for AI applications.

The three pieces

MCP has three core concepts:

flowchart LR
    HOST[Host application<br/>Claude Desktop, Cursor, etc.]
    CLIENT[MCP Client<br/>built into the host]
    SERVER[MCP Server<br/>connects to your data]
    DATA[Your data<br/>Notion, GitHub, files...]

    HOST --> CLIENT
    CLIENT -.MCP protocol.-> SERVER
    SERVER --> DATA

The host

The AI application you actually use, Claude Desktop, Cursor, ChatGPT Desktop, Windsurf. You interact with the host, not with MCP directly.

The client

A small piece of code inside the host that speaks MCP. You usually do not see it. Every MCP-enabled host has a client built in.

The server

A separate program that exposes some data or capability to MCP clients. Servers are written by anyone, Anthropic ships a few official ones (filesystem, GitHub), and the community has built hundreds more (Notion, Linear, Stripe, Spotify, Figma, etc.).

You as a developer mostly write servers. Clients are baked into existing AI apps. Servers are where new value gets added.

What a server actually exposes

An MCP server can expose three kinds of things:

flowchart TB
    SERVER[MCP Server]
    SERVER --> TOOLS[Tools<br/>actions the AI can take]
    SERVER --> RESOURCES[Resources<br/>data the AI can read]
    SERVER --> PROMPTS[Prompts<br/>templates users can pick]

    TOOLS --> T1["create_issue()"]
    TOOLS --> T2["send_message()"]
    RESOURCES --> R1[file://README.md]
    RESOURCES --> R2[notion://page/abc]
    PROMPTS --> P1["Summarize this PR"]
    PROMPTS --> P2["Review this code"]

Tools

Functions the AI can call. “Create a GitHub issue.” “Send a Slack message.” “Search the database.” Tools are how the AI does things.

Resources

Data the AI can read. “The contents of this file.” “This Notion page.” “This API response.” Resources are how the AI knows things.

Prompts

Pre-written templates the user can pick from. “Summarize this pull request.” “Translate this code to TypeScript.” Prompts are user-facing shortcuts.

In your first MCP server you will probably only use Tools. The other two are for fancier use cases.

How a real conversation flows

Imagine you are in Claude Desktop and you ask:

“What are the latest issues in my GitHub repo, and create a new one summarizing them?”

Here is what happens behind the scenes:

sequenceDiagram
    participant U as You
    participant C as Claude Desktop
    participant S as GitHub MCP Server
    participant G as GitHub API

    U->>C: 'List issues, then create a new one'
    C->>S: list_issues(repo='my-repo')
    S->>G: GET /repos/my-repo/issues
    G->>S: returns 5 issues
    S->>C: 5 issues
    C->>C: Summarizes the issues
    C->>S: create_issue(title='Summary', body='...')
    S->>G: POST /repos/my-repo/issues
    G->>S: issue created (#42)
    S->>C: success, issue #42
    C->>U: 'Done. Created issue #42.'

Note: Claude does not call GitHub directly. It calls the MCP server, which calls GitHub. This separation is what makes MCP useful, the server knows how to talk to GitHub, Claude does not need to.

Transports: stdio vs HTTP

MCP servers run as separate processes. They need to talk to the client somehow. There are two transports:

For your first server, use stdio. It’s the simplest and works with Claude Desktop, Cursor, and most clients.

Installing your first MCP server

Let’s see this in action. The official filesystem server lets Claude read and search local files. Here is how to enable it in Claude Desktop:

1. Open ~/Library/Application Support/Claude/claude_desktop_config.json (Mac) or the equivalent on your OS.

2. Add this config:

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

3. Restart Claude Desktop.

4. Try it. Open a new conversation and ask: “What’s in my Documents folder?” Claude will now have a filesystem tool available and can answer.

That is your first working MCP server. It launches when Claude starts, and Claude can call it to list files, read them, and search.

Why this is a big deal

Before MCP, every AI integration was bespoke. To connect ChatGPT to your custom internal tool, you had to wait for OpenAI to build a plugin, or build a complex web app.

With MCP, you write one server for your tool, and every MCP-compatible AI client can use it. Claude Desktop, Cursor, Zed, future clients, all of them, for free.

This is why MCP is exploding in 2026:

• Hundreds of community servers for popular tools (Notion, Linear, Spotify, Figma, etc.)
• Anthropic ships official servers for filesystem, GitHub, Slack, and more
• Companies are shipping official MCP servers (Stripe, Linear, Cloudflare, etc.)
• A new MCP registry lets users discover and install servers

If you build developer tools or AI features, MCP is now the standard way to expose them.

Common confusions

Is MCP just function calling? Sort of. Function calling is a low-level capability. MCP is a higher-level protocol that wraps function calling and adds: discovery (find available tools), schemas, resources, prompts, transports, and a standard handshake. Function calling is the engine; MCP is the highway system.

Do I need to use the official SDKs? You can write a server in any language as long as it speaks the MCP JSON-RPC protocol. Official SDKs exist for TypeScript, Python, Rust, Java, Kotlin, Swift, and C#. Use them. They handle the protocol details for you.

Can the AI run any code it wants on my machine? No. The MCP server defines what tools exist. The AI can only call those specific tools. If your server exposes list_files() and read_file(), those are the only things the AI can do.

Is MCP secure? The protocol itself is fine, but the security depends on what your server does. If your server exposes a delete_file() tool, the AI can delete files. Always think about what powers you are granting before adding a server.

What’s next in this curriculum

This was the overview. The next articles take you all the way to shipping your own server:

• 02, MCP Architecture: Clients, Servers, and Transports (coming up)
• 03, Setting Up Your First MCP Server in 30 Minutes (week 3)
• 04, Tools, Resources, and Prompts: The MCP Primitives (week 4)
• … and 5 more

By article 09 you’ll have shipped a real MCP server, published it, and learned how to monetize one.

What to remember

• MCP is a protocol, like HTTP, but for AI apps connecting to data and tools
• Three pieces: host (the AI app), client (inside the host), server (you write this)
• A server exposes Tools (actions), Resources (data), Prompts (templates)
• stdio transport for local servers, HTTP for remote
• Hundreds of servers already exist, install one and try it
• This is the standard way to extend AI apps in 2026

What to study next

1. The official MCP spec at modelcontextprotocol.io, short and well-written
2. Anthropic’s MCP launch blog post, gives the original motivation
3. The MCP server registry at mcp.so, browse existing servers

Or just install the filesystem server (steps above) and play with it for 10 minutes. Hands-on beats reading.

Next week: MCP Architecture: Clients, Servers, and Transports.

Further reading

• modelcontextprotocol.io. The official protocol specification, SDK docs, and example servers.
• Anthropic — Introducing the Model Context Protocol. The original announcement with motivation and architecture.
• Smithery. Public registry of MCP servers; useful for both discovery and to see how others structure their servers.
• MCP — Build a server (TypeScript). Official tutorial for shipping your first MCP server.

Where this article comes from. This is a synthesis of common practice in AI engineering as of 2026, not a citation of any single paper. The sources above are where the broad mechanics and specific numbers come from. If you find an error or have a better source for a claim, the article gets fixed within a day, send me a note.