Skip to main content

Class 1: Why MCP Exists

Duration: ~20 minutes | Level: Beginner | Prerequisites: None, this is where everything starts.

Which spec revision this course teaches

This course teaches the protocol itself instead of any one SDK, so it tracks the current specification: 2026-07-28, published 28 July 2026. A revision is named by a date in the form YYYY-MM-DD, the last date on which a change broke backwards compatibility. The spec calls revisions up to 2025-11-25 legacy, calls 2026-07-28 and later modern, and its compatibility matrix gives the outcome of each pairing:

ClientServerOutcome
ModernModernWorks. A version the server does not support comes back as UnsupportedProtocolVersionError, code -32022, listing the versions it does support, and the client retries with one of those.
ModernLegacyFails. The legacy server may reject the request with an error of its own choosing, or stay silent.
LegacyModernFails. A legacy client cannot move forward to a newer revision.
Dual-eraModern or legacyWorks. The client probes the server, sees which era answers, and speaks that one.
LegacyDual-eraWorks. The server answers initialize and serves the legacy revision.

Plenty of deployed servers, and the Java MCP SDK 2.0.0, are still legacy. So where a mechanism changed, this course labels it with the revision it belongs to instead of dropping the older form: understanding why the old design was replaced is most of the value. The Java courses on this site pin to 2025-11-25 deliberately, because that is what the Java SDK can actually run.

The Problem: A Model That Cannot Reach Anything​

A large language model is in the position of an expert locked in a windowless room. People pass notes under the door and the expert writes replies. The advice can be very good, but the expert can only work with what the note contains.

ChatGPT, Claude and Gemini reason, write and synthesise information well. By default, though, they know only what is in their training data, the text they learned from before release, and whatever you paste into the prompt. They cannot:

  • Query your database
  • Read a file from your filesystem
  • Call your company's internal API
  • Check what's currently in your calendar
  • Look at the error your application threw five minutes ago

Only two paths carry information into the model:

Nothing connects the model to the five boxes on the right. This is an architectural limitation: the model is trained on data fixed at training time, while the information it would need changes constantly. Something has to carry that changing information in to the model.

The First Wave: Ad-hoc Integrations​

When OpenAI released GPT-4's function-calling feature in 2023, developers rushed to connect AI to the real world. "Function calling" is the model API feature where you describe a set of functions to the model: name, parameters, and what each does. The model can then ask your code to run one of them with structured arguments, a JSON object matching the parameter schema you declared, instead of producing text. The pattern was simple:

  1. Define functions in the API request
  2. The model decides when to call them
  3. Your code executes the function and feeds results back

Those three steps travel as six messages:

Only your application touches the database. The model asks for the function to be run, and your application decides whether to run it.

Function calling connected models to real systems and is still in wide use, but every integration was completely custom. You wrote the tool definition, the execution logic, and the result-handling for every application, every model, every use case. If you wanted the same database tool to work in your internal chatbot and in the AI code assistant your team was evaluating, you wrote it twice. If you switched AI providers, you rewrote the tool layer from scratch. The API contract changed between OpenAI and Anthropic and Google, incompatibly.

Every AI application needed its own integration with every tool:

AI applicationsTools or data sourcesIntegrations written ad-hocIntegrations written with MCP
2244
34127
5105015
102020030

The ad-hoc column multiplies the two counts, and the MCP column adds them.

Enter MCP: A Standard Protocol​

In November 2024, Anthropic published the Model Context Protocol (MCP), an open standard for connecting AI models to external tools and data sources.

Agree on one protocol for how an AI model communicates with external capabilities, and each side is implemented once. The server author implements the protocol instead of one integration per client, and the client author instead of one integration per server.

  • MCP servers expose capabilities: tools the model can run, resources it can read, prompts the user can pick. Class 3 takes each one apart.
  • MCP clients, embedded in AI applications, consume them. Class 2 separates the four actors: host, client, server and model.
  • The protocol between them is standardised: JSON-RPC 2.0 names a method, passes its arguments as JSON and returns a JSON result. It travels over a defined transport, the channel the messages take: a local pipe or an HTTP connection. Class 4 covers the messages, Class 5 the transports.

Build an MCP server for your database once, and every MCP-compatible AI application that speaks a revision your server also speaks can use it. Switching from Claude Desktop to Cursor to a custom agent framework leaves the server unchanged, and a server that wants both eras implements both. Before and after:

The three custom integrations on the left collapse into one protocol on the right. The server also holds the credentials and decides what each client may do. Class 7 covers consent, token audience, and what a server must refuse.

Why Anthropic? Why Now?​

Why did Anthropic create this, and not OpenAI? OpenAI was the bigger player at the time and had the market reach to impose a standard on its own. MCP came from Anthropic for a pragmatic reason: Anthropic was building Claude's tool-use capabilities and Claude Desktop simultaneously. They were building both sides themselves, which exposed the full cost of ad-hoc integration. The protocol emerged from internal necessity and was open-sourced.

Why 2024? Several things converged: models were finally capable enough that tool use became the bottleneck. Autonomous agents ("agentic AI", meaning AI systems that decide on their own which actions to take to achieve a goal, instead of responding to a single instruction) became a serious engineering concern. And the ecosystem was fragmented enough that developers were loudly demanding a standard.

Adoption​

A protocol is only useful once enough implementations speak it. Within months of publication, MCP was integrated into:

ApplicationWhat it is
Claude DesktopAnthropic's own application
Cursorone of the leading code editors built around a model
Zedthe editor
GitHub CopilotMicrosoft's coding assistant
Continueopen-source AI coding assistant

Dozens of community tools and frameworks followed. ChatGPT and Gemini became MCP clients later, so by December 2025 the list covered OpenAI, Google, Microsoft and Anthropic products.

The community published over a thousand MCP servers within the first six months. By the time MCP entered the Linux Foundation in December 2025, the published counts looked like this:

MeasureValueAs ofPublished in
MCP Registry entriesclose to 2,00025 November 2025One Year of MCP
Published MCP serversmore than 10,0009 December 2025Linux Foundation press release
Monthly SDK downloadsover 97 million9 December 2025MCP project announcement

SDK here means the client and server libraries the project publishes for Python, TypeScript, Java and other languages. The numbers keep moving, so follow the links for the current ones.

On 9 December 2025, MCP became a founding project of the newly-formed Agentic AI Foundation (AAIF), a under the Linux Foundation co-founded by Anthropic, Block, and OpenAI, formalising it as a vendor-neutral industry standard.

What MCP Is Not​

Four things MCP is often mistaken for:

MCP is notWhat is true instead
a modelClaude, GPT and Gemini do the reasoning. MCP carries the tool calls they produce and does not add any AI capability of its own.
a cloud serviceYour own processes. You run every MCP server yourself: locally over a pipe, or remotely over HTTP.
an agent frameworkLangChain, LangGraph and CrewAI in Python, or LangChain4j and Embabel on the JVM, run the higher-level loop of "decide what to do next, then what, then what". They call MCP to reach the tools the agent asks for.
Anthropic-onlyAn open specification, governed since December 2025 by the Agentic AI Foundation. Any client and any server can implement it, and Claude is one client among many.

What to Take Into the Next Class​

The problem MCP addresses is one of coordination. Without an agreed protocol, the same database or ticketing system gets wrapped once per application.

HTTP and USB-C did the same thing in their own areas. In both cases the technology underneath changed relatively little, and what changed was the contract: the shared agreement about how two things communicate, which let anyone build either side independently.

The dates in order:

This course teaches the last box, and the Java courses on this site teach the third.

In the next class, we look at the four actors in the MCP contract and how they relate.

Further Reading​

Sources​