The Model Context Protocol

+15 Mana ✨
Introduction to MCP(DOCUMENTATION)MCP Specification(DOCUMENTATION)

Introduction

Every time a new LLM-powered application wants to integrate with an external tool or data source, developers build a custom integration from scratch. If you have N language models and M tools, you end up writing N times M individual connectors. This is the N times M integration problem, and it is the exact pain point that the Model Context Protocol was created to solve.

MCP is an open standard, created by Anthropic and released as an open-source specification, that provides a universal way for LLMs to discover and interact with tools, data sources, and services. Think of it as USB-C for AI: just as USB-C replaced a tangle of proprietary charging cables with a single universal connector, MCP replaces bespoke LLM integrations with a single standardized protocol.

Key Concepts

  • The N times M Problem: Without a standard, every combination of LLM host and external tool requires its own integration code. Three hosts and five tools means fifteen custom integrations. MCP reduces this to N plus M: each host implements the protocol once, each tool implements it once, and they all work together.
  • Universal Standard: MCP defines a common language for tool discovery, invocation, and data exchange between LLMs and external systems.
  • Open Source Specification: The protocol specification is publicly available and versioned. Anyone can build MCP-compatible hosts and servers.
  • MCP vs Function Calling: Function calling is the mechanism by which an LLM requests that a specific function be executed (the "how"). MCP is the protocol that standardizes how tools are discovered, described, and invoked across different hosts (the "what" and "where"). Function calling happens inside MCP.

Real World Context

Consider the current AI tool ecosystem. Claude Desktop needs to access your file system, query a database, and post to Slack. Without MCP, the Claude Desktop team would build three separate integrations. Now Cursor wants the same three tools — three more integrations. Add VS Code, Windsurf, and Cline, and you are looking at fifteen custom implementations for just three tools. With MCP, each tool is built once as an MCP server, and each host connects to any server through the standard protocol.

Today, MCP is used by Claude Desktop, Claude Code, VS Code (via GitHub Copilot), Cursor, Windsurf, Cline, and a growing number of AI-powered development tools.

Deep Dive

The Integration Problem Visualized

Without MCP, the integration landscape looks like this:

text
Claude Desktop ──custom──> File System
Claude Desktop ──custom──> GitHub
Claude Desktop ──custom──> PostgreSQL
Cursor         ──custom──> File System
Cursor         ──custom──> GitHub
Cursor         ──custom──> PostgreSQL
VS Code        ──custom──> File System
VS Code        ──custom──> GitHub
VS Code        ──custom──> PostgreSQL

That is nine integrations for three hosts and three tools. Every new host or tool adds an entire row or column.

With MCP, each side implements the protocol once:

text
Claude Desktop ──MCP──┐
Cursor         ──MCP──┤──> File System Server
VS Code        ──MCP──┘──> GitHub Server
                       └──> PostgreSQL Server

Now adding a new host means implementing MCP once. Adding a new tool means building one MCP server. The total integration count is N plus M instead of N times M.

How MCP Relates to Function Calling

It is important to understand the relationship between MCP and LLM function calling:

text
┌─────────────────────────────────────────────────┐
│ MCP (Protocol Layer)                            │
│                                                 │
│  Tool Discovery ──> Tool Description            │
│       │                    │                    │
│       ▼                    ▼                    │
│  LLM sees available   LLM decides to call       │
│  tools via MCP        a tool (function calling) │
│                            │                    │
│                            ▼                    │
│                    MCP routes the call           │
│                    to the right server           │
└─────────────────────────────────────────────────┘

Function calling is the LLM's ability to output structured requests for actions. MCP is the protocol that tells the LLM what tools exist, what parameters they accept, and how to route the call to the correct server. They are complementary, not competing.

Who Created MCP and Why

Anthropic introduced MCP in late 2024 as an open-source specification. The goal was to prevent fragmentation in the AI tool ecosystem — the same kind of fragmentation that plagued mobile charging cables before USB-C. By releasing MCP as an open standard, Anthropic ensured that any AI host or tool vendor can adopt it without licensing restrictions.

Common Pitfalls

  1. Confusing MCP with function calling — MCP and function calling operate at different layers. Function calling is the mechanism an LLM uses to request an action. MCP is the protocol that standardizes how tools are discovered, described, and invoked. An LLM uses function calling within the MCP framework to call MCP-defined tools.
  2. Thinking MCP replaces REST APIs — MCP does not replace your existing APIs. MCP servers often wrap REST APIs, databases, or file systems to make them accessible to LLMs through a standardized interface. Your REST API continues to serve non-LLM clients as before.
  3. Assuming MCP is Anthropic-only — While Anthropic created MCP, it is an open standard adopted by many tools including VS Code, Cursor, Windsurf, and Cline. Any application can implement MCP.

Best Practices

  1. Think in terms of servers, not integrations — Instead of building a custom integration between your AI app and each tool, build or adopt MCP servers. Each server encapsulates one tool or data source and works with any MCP-compatible host.
  2. Start with existing MCP servers — Before building your own, check the MCP ecosystem for pre-built servers for common tools like file systems, GitHub, databases, and messaging platforms.

Summary

  • MCP solves the N times M integration problem by providing a universal protocol for LLM-to-tool communication.
  • Created by Anthropic as an open-source specification, MCP is adopted by Claude Desktop, Claude Code, VS Code, Cursor, Windsurf, Cline, and more.
  • MCP is like USB-C for AI: a single standard connector replacing many proprietary ones.
  • Function calling is the mechanism by which an LLM requests actions; MCP is the protocol that standardizes tool discovery and invocation across hosts.

Code Examples

json
{
  "name": "filesystem",
  "description": "MCP server for file system operations",
  "tools": [
    { "name": "read_file", "description": "Read a file from disk" },
    { "name": "write_file", "description": "Write content to a file" },
    { "name": "list_directory", "description": "List files in a directory" }
  ]
}
✓ Completed