Intermediate

What is MCP?

The Model Context Protocol (MCP) is an open standard for connecting AI models to external tools, data sources, and services. Announced by Anthropic in November 2024 and adopted as an industry standard by March 2025, MCP solves a fundamental problem: before MCP, every AI tool integration required bespoke connector code. With MCP, any AI application can connect to any MCP server using one protocol — like USB-C for AI.

The Problem MCP Solves

Before MCP, if you wanted Claude to read files, search the web, query a database, and access GitHub — you needed four separate custom integrations, each built differently, each maintained separately, and each tightly coupled to your specific AI application. If you switched from Claude to GPT-4, you rebuilt all four integrations. If a new data source appeared, you wrote another bespoke connector.

Before MCP

Each tool integration: bespoke code, different APIs, different authentication
N tools × M AI applications = N×M integrations to maintain
Integration breaks when tool API changes
No standardised way for AI to discover what a tool can do
Tool calling worked, but wiring tools to data sources required custom glue

With MCP

Build one MCP server for a tool/data source
Any MCP client (Claude, ChatGPT, Cursor, VS Code) can connect to it
N tools + M AI applications = N + M integrations
AI discovers capabilities at connection time via the protocol
Standardised authentication, error handling, and capability negotiation

Client / Server Architecture

MCP follows a client/server model. The AI application (or its framework) is the MCP client. The external system exposing capabilities is the MCP server. The protocol runs over standard transports: stdio (for local processes), HTTP with Server-Sent Events, or WebSockets.

MCP Client (your AI application)

Claude / ChatGPT / Cursor / VS Code

Discovers + calls server capabilities

MCP Protocol (stdio / HTTP+SSE / WebSocket)

tools/list

Discover tools

tools/call

Execute tool

resources/list

Discover data

resources/read

Read data

MCP Servers (external systems)

GitHub Server

PRs, issues, code

Postgres Server

Tables, queries

Filesystem Server

Read/write files

Slack Server

Channels, messages

N tools + M AI apps = N + M integrations. Before MCP: N × M.

The Three MCP Primitives

Every MCP server exposes capabilities through exactly three primitives. Understanding these is the key to understanding what MCP servers can offer and how AI applications consume them.

1. Tools — Executable functions

Tools are functions the AI can call to perform actions or retrieve computed results. They are the MCP equivalent of tool calling / function calling in standard LLM APIs. Each tool has a name, description (used by the AI to decide when to call it), and a JSON Schema for its input parameters.

Examples: search_github(query), run_sql(query), send_slack_message(channel, text), read_file(path)

2. Resources — Data and context

Resources are data sources the AI can read. Unlike tools (which execute actions), resources provide static or semi-static content that the AI uses as context. Resources are identified by URIs and can be text, binary, or structured data.

Examples: file:///path/to/document.pdf, db://table/users, git://repo/README.md, slack://channel/general/history

3. Prompts — Templated interactions

Prompts are pre-defined, parameterised message templates that the MCP server exposes for the AI to use. They encode best-practice workflows for common tasks on that server — effectively expert prompts bundled with the integration.

Examples: "Summarise this pull request" template for a GitHub server; "Write a SQL migration for this schema change" template for a DB server

How MCP Works in Practice

Connect

AI app connects to configured MCP servers

→

Handshake

Client + server exchange version and capabilities

→

Discover

tools/list + resources/list + prompts/list

→

Expose to LLM

Tools added to LLM tool list

→

LLM decides

Reads descriptions, selects which tool to call

→

Execute + return

Client calls server, returns result to LLM

Capability discovery happens at connection time — the LLM sees every tool description and selects the right one per task

Adoption and Governance (2025)

MCP grew from an Anthropic internal experiment to the de-facto industry standard within months of its November 2024 release.

November 2024: Anthropic open-sources MCP. Pre-built servers released for Google Drive, Slack, GitHub, Git, Postgres, Puppeteer.

March 2025: OpenAI officially adopts MCP and integrates it into ChatGPT desktop app. MCP becomes cross-vendor standard.

2025 ecosystem: 16,000+ MCP servers indexed on mcp.so. SDKs available for all major programming languages. Cursor, VS Code, Claude Code, Zed, and dozens of AI tools support MCP natively.

Governance: Anthropic donates MCP to the Agentic AI Foundation (AAIF), a directed fund under the Linux Foundation. Co-founded by Anthropic, Block, and OpenAI — with Google, Microsoft, AWS, Cloudflare, and Bloomberg as supporting members.

MCP vs Direct Tool Calling

Dimension	Direct tool calling	MCP
Integration scope	Per-app, per-model	Write once, use with any MCP client
Capability discovery	Defined in application code	Dynamic at connection time (tools/list)
Data / context access	Requires custom retrieval code	Resources primitive handles this
Portability	Not portable across AI apps	Any MCP client can connect
Ecosystem	Proprietary per vendor	16,000+ community servers

Checklist: Do You Understand This?

What problem did MCP solve that direct tool calling did not?
What are the three MCP primitives — Tools, Resources, and Prompts — and what does each one represent?
In the MCP architecture, which side is the client and which is the server? Give an example of each.
How does capability discovery work when an MCP client first connects to a server?
What is the USB-C analogy for MCP and why is it apt?
Why did MCP adoption accelerate so quickly, and what role did OpenAI's March 2025 adoption play?