Module 1: Why MCP Exists
Duration: ~20 minutes | Level: Beginner | Prerequisites: None, this is where everything starts.
This course teaches the protocol itself rather than any SDK, so it tracks the current specification: 2026-07-28, ratified 28 July 2026. That revision is a hard break with everything before it. The spec calls revisions up to 2025-11-25 legacy and 2026-07-28 and later modern, and its own compatibility matrix says a modern client talking to a legacy-only server fails, as does the reverse.
Plenty of deployed servers, and the Java MCP SDK 2.0.0, are still legacy, so a mechanism that changed is labelled with the revision it belongs to rather than deleted: knowing why the old design was dropped 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: Brilliant, Isolated AI
Imagine a world-class expert who knows everything about medicine, law, engineering, and literature, but is locked in a windowless room with no phone, no computer, no connection to the outside world. People can pass notes under the door, and the expert writes responses. The advice is excellent. But there's one fundamental limitation: the expert can only work with what's in the note.
That's a large language model.
ChatGPT, Claude, Gemini, they're extraordinarily capable at reasoning, writing, and synthesising information. But by default, they only know what's in their training data 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
This isn't a capability failure. It's an architecture limitation. The model is trained on static data. The real world is dynamic. Something has to bridge that gap.
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, what each does), and the model can request that your code run one of them with structured arguments instead of just producing text. The pattern was simple:
- Define functions in the API request
- The model decides when to call them
- Your code executes the function and feeds results back
This worked. Sort of.
The problem was that 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.
What the industry was recreating, inadvertently, was the pre-USB world of proprietary connectors. Every device had its own port. Every integration required its own cable.
Enter MCP: A Standard Protocol
In November 2024, Anthropic published the Model Context Protocol (MCP), an open, vendor-neutral standard for connecting AI models to external tools and data sources.
The core insight behind MCP is elegantly simple: if you define a universal protocol for how an AI model should communicate with external capabilities, you only have to implement each side once.
- MCP servers expose capabilities: tools, resources, and prompts
- MCP clients (embedded in AI applications) consume them
- The protocol between them is standardised: JSON-RPC 2.0 over a defined transport
Build an MCP server for your database once. Every MCP-compatible AI application can use it. Switch from Claude Desktop to Cursor to a custom agent framework? Your server works without modification.
Why Anthropic? Why Now?
Two questions are worth addressing directly.
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, but MCP came from Anthropic for a pragmatic reason: Anthropic was building Claude's tool-use capabilities and Claude Desktop simultaneously. They were eating their own cooking at a scale that exposed all the pain 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, not the model itself. Autonomous agents ("agentic AI", i.e. AI systems that decide on their own which actions to take to achieve a goal, rather than responding to a single instruction) became a serious engineering concern. And the ecosystem was fragmented enough that developers were loudly demanding a standard.
Rapid Adoption: The Signal That This Matters
The measure of a protocol is adoption, not the specification document. Within months of publication, MCP was integrated into:
- Claude Desktop (Anthropic's own application)
- Cursor (one of the leading AI-native code editors)
- Zed (the editor)
- GitHub Copilot (Microsoft)
- Continue (open-source AI coding assistant)
- Dozens of community tools and frameworks
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 ecosystem had grown to roughly 10,000 active servers and around 97 million monthly SDK downloads (figures from the Linux Foundation announcement). On 9 December 2025, MCP became a founding project of the newly-formed Agentic AI Foundation (AAIF), a directed fund under the Linux Foundation co-founded by Anthropic, Block, and OpenAI, formalising it as a vendor-neutral industry standard. Integration moved from being a competitive differentiator to being a commodity table-stakes feature.
What MCP Is Not
Clarity requires knowing the edges:
- MCP is not a model. It does not provide any AI capability itself. It is a protocol for connecting models to capabilities.
- MCP is not a cloud service. There's no MCP SaaS to subscribe to. It runs wherever your servers and clients run.
- MCP is not an AI agent framework. Agent frameworks handle the higher-level loop of "decide what to do next, then what, then what": LangChain, LangGraph, and CrewAI in Python, or LangChain4j and Embabel on the JVM. MCP is the protocol those frameworks use (or should use) to connect to the tools the agent reaches for.
- MCP is not Anthropic-only. The specification is open. Any client and any server can implement it. Claude is one client among many.
The Key Insight to Carry Forward
MCP solves a coordination problem. Without it, every AI application reinvents the integration layer. With it, the integration layer becomes a shared infrastructure.
This is the same shift that HTTP enabled for the web, or that USB-C enabled for charging. The technology underneath changed relatively little. What changed was the contract, the shared agreement about how things should communicate.
In the next module, we'll look at the four actors in that contract and how they relate.