What Is MCP?

Overview

Every AI coding agent needs to interact with the world beyond its language model -- reading files from a database, creating issues in a project tracker, querying a search engine, or calling an internal API. Before the Model Context Protocol (MCP), each of these integrations was a bespoke, tightly coupled piece of code. MCP changes that by providing a single, open standard for connecting agents to external tools and data sources. This lesson explains what MCP is, why it exists, and why it matters for anyone building agent-ready systems.

The Integration Problem

Imagine you are building an AI coding agent that needs to interact with GitHub, a PostgreSQL database, and your company's Jira instance. Without a standard protocol, you face an unpleasant reality:

Before MCP: Agent A and Agent B each need separate custom integration code for GitHub, Database, and Jira — resulting in six custom integrations for just two agents and three tools.

Each agent-tool pair requires its own custom integration code. Agent A's GitHub integration does not work with Agent B. Agent B's database connector cannot be reused by Agent A. Every new agent or tool multiplies the number of integrations you need to write and maintain.

This is the M-times-N problem: M agents times N tools equals M x N custom integrations. It does not scale.

The USB-C Analogy

To understand why MCP matters, think about what USB-C did for hardware. Before USB-C, your desk was a tangle of proprietary cables -- one for your phone, a different one for your tablet, another for your monitor, yet another for your external drive. Each device-cable combination was a unique integration.

USB-C introduced a single standard connector. Any device that speaks USB-C can connect to any peripheral that speaks USB-C. The number of cables you need dropped from M x N to M + N.

After MCP: Agent A and Agent B both connect to the same MCP servers (GitHub, Database, Jira) through the standard MCP protocol — each server is written once and works with any agent.

MCP is USB-C for AI agents. Write a server once, and any MCP-compatible agent can use it. Build an agent once, and it can talk to any MCP server. The integration burden drops from multiplicative to additive.

What MCP Actually Is

The Model Context Protocol is an open standard, originally created by Anthropic and now adopted across the industry, that defines how AI agents communicate with external tools and data sources (see MCP Specification). At its core, MCP specifies:

• A message format -- how requests and responses are structured (JSON-RPC 2.0)
• A transport layer -- how messages travel between agent and tool (stdio or HTTP with Server-Sent Events)
• A capability model -- what kinds of things a server can expose (tools, resources, prompts)

MCP does not replace your existing APIs. Instead, it wraps them in a standard interface that any agent can discover and use.

The Three Primitives

MCP organizes everything a server can expose into three categories, called primitives:

The three MCP primitives: Tools (actions the agent calls, like create_issue, search_code, run_query), Resources (data the agent reads, like file contents, DB schemas, config), and Prompts (templates the agent uses, like code review, bug report, analysis).

Tools are functions the agent can call to take actions. Examples include creating a GitHub issue, running a database query, or sending a Slack message. Tools are the most commonly used primitive -- they give the agent the ability to do things in the world.

Resources are data the agent can read. Examples include file contents, database schemas, or configuration values. Resources provide context without requiring the agent to take an action. Think of them as read-only endpoints.

Prompts are reusable templates that guide the agent's behavior for specific tasks. A server might offer a "code review" prompt template that structures how the agent should analyze a pull request. Prompts are the least commonly used primitive but can be powerful for standardizing agent workflows.

Who Uses MCP Today

MCP is not a theoretical standard -- it is already integrated into the tools developers use daily:

• Claude Code -- Anthropic's CLI agent uses MCP to connect to GitHub, Jira, databases, and custom tools
• Claude Desktop -- the desktop application supports MCP servers for extending the agent's capabilities
• Cursor -- the AI-native editor supports MCP servers
• Windsurf -- supports MCP for tool integration
• VS Code extensions -- the GitHub Copilot extension and others are adopting MCP
• Open-source agents -- many community-built agents use MCP as their tool integration layer

Why MCP Matters for Agent-Ready Codebases

If you have been following this academy, you know that an agent-ready codebase provides context, conventions, constraints, and feedback loops. MCP adds a fifth dimension: capabilities.

With MCP, your CLAUDE.md can tell the agent not just what to do, but which tools are available to do it:

When you configure MCP servers for your project, every agent on your team gains the same capabilities -- querying the same databases, accessing the same issue tracker, using the same internal APIs. This is infrastructure-level consistency that would be impossible with per-agent custom integrations.

MCP also enables a clean separation of concerns. The agent focuses on reasoning and planning. The MCP server handles the messy details of API authentication, rate limiting, and data transformation. Neither needs to know the internals of the other.

The Ecosystem at a Glance

The MCP ecosystem has three layers:

The MCP ecosystem in three layers: Agent Layer (Claude Code, Cursor, custom agents), Protocol Layer (JSON-RPC, stdio/SSE transport), and Server Layer (GitHub, Jira, databases, custom servers). The protocol layer connects agents to servers.

• The agent layer includes any application that embeds an MCP client -- Claude Code, Cursor, or your own custom agent
• The protocol layer is the standard itself -- the message formats, transport mechanisms, and capability negotiation
• The server layer includes all the MCP servers that wrap external services and expose them to agents

You can participate at any layer. Most teams start at the agent layer (using existing MCP servers), then move to the server layer (building custom servers for their domain-specific tools).

Summary

The Model Context Protocol solves the M-times-N integration problem by providing a single standard for connecting AI agents to external tools and data sources. Like USB-C for hardware, MCP lets you write a server once and have it work with any compatible agent. The protocol organizes capabilities into three primitives -- tools, resources, and prompts -- and communicates over JSON-RPC via stdio or HTTP. MCP is already integrated into Claude Code, Cursor, and many other tools, with a rapidly growing ecosystem of pre-built servers. In the next lesson, we will look under the hood at how the MCP architecture works.