In this blog, you’ll learn what MCP (Model Context Protocol) is, why it matters, and how it could fundamentally change how we build AI-powered systems. By the end, you’ll understand how to think about MCP in real architectures.
Why MCP matters
Over the past year, we’ve realised the potential of LLMs but connecting them to the real world is still messy. In practice, every AI application relies on custom integrations where APIs are manually stitched together. As a result, scaling beyond simple demos becomes difficult and time consuming. In short, we’ve built a consistent foundation for models—but not for how they connect and operate in the real world.
Three Core Ideas
Before diving into MCP, it helps to simplify three core ideas.
First – Context is everything.
Large language models contain knowledge learned from their training data, but they don’t access it like a database. Instead, they generate responses dynamically based on the context they’re given at runtime—the prompt, instructions, and any additional data we provide. As we’ve seen with approaches like RAG, the quality of the output is heavily dependent on how well that context is constructed.
Second – Grounding
While LLMs are trained on vast amounts of data, they’re still limited—especially when it comes to real-time or enterprise-specific information. To bridge that gap, there is a dependency on external data sources tools such Systems of Records (via APIs) and databases. These allow models to go beyond their training data and interact more effectively with the real world.
Third – Orchestration
Ochestration of context is where much of the hidden complexity in managing context resides. One of the key challenges today is the lack of a consistent and standardised way for LLMs to access external data and effectively shape it into usable context. Frameworks like LangChain have made progress in this space, but they largely rely on ad hoc patterns, significant amounts of glue code, and highly custom integrations. As a result, solutions can feel fragmented and difficult to scale. Together, these limitations are starting to highlight the need for a more structured and standardised approach.
The Big Shift
Anthropic has stepped into this space with an important announcement—MCP (Model Context Protocol). MCP feels like one of those early signals that something fundamental is about to change. Up until now, much of the effort in building LLM-powered systems has gone into stitching together context, tools, and data through custom orchestration layers—with no real standard to guide us. MCP introduces the idea that context and tool interaction shouldn’t be improvised but defined through a consistent interface. What makes this important isn’t just the protocol itself, but the direction it sets: a move away from ad hoc integrations towards a more structured, interoperable way of building AI systems. If it gains traction, MCP could do for AI interactions what APIs did for software—turning fragmented, bespoke implementations into something far more reusable, scalable, and predictable.
How MCP Works
So how should we think about MCP at a high level? It’s still early days, but conceptually, MCP introduces a more structured way of organising how models interact with context and tools. At its core, MCP brings together three key components:
1. Model
This is the LLM itself—whether that’s Claude, GPT, or any other model. The model remains the reasoning engine, but it no longer operates in isolation; it’s designed to work within a more defined environment.
2. Context Layer
Rather than treating prompts as unstructured text, MCP frames context as a more structured input layer. The idea here is to make context more explicit and manageable, rather than something we manually assemble each time. MCP gets its context sing tools (see below)
3. Tool Interface
Unlike traditional hardcoded function calling, MCP tools are designed to be truly pluggable. This means you can define a tool once, and any AI application or agent that supports MCP can discover and use it without requiring bespoke integrations for each individual model. In effect, this shifts tool usage from custom-built connections to a more standardised, reusable approach. Rather than relying on bespoke integrations, it proposes an approach where tools are clearly described so the model can understand their purpose, invoked through a defined and consistent interface, and designed to return structured results that can be fed back into the model’s context.
Example of a MCP Tool definition
An MCP tool is essentially a well-defined capability that is clearly described so the AI understands how and when to use it. It specifies what the tool does—for example, retrieving customer data—along with the situations in which it should be used, such as when a user asks about a customer. It also defines the inputs required, like a customer ID, and the type of output it will return, such as a structured customer profile. Together, this structured description allows the model to reliably decide when to use the tool and how to integrate its results into a response.
MCP Architecture
At its core, MCP follows a client–server model with three main components:
1. MCP Host (AI Application)
The host is the application that embeds or runs the language model.
2. MCP Client (Connector Layer)
The client sits inside the host and acts as the communication layer. Maintains a connection with one or more MCP servers. Each client typically manages a session with a specific server.
3. MCP Server (Context & Capability Provider)
The server exposes data and functionality to the AI system. Servers provide three fundamental primitives:
Resources → structured data (files, documents, records)
Tools → executable functions (search, query, update)
Prompts → reusable workflows/templates
How it works
- The host receives a user request
- The host delegates to an MCP client
- The client queries one or more MCP servers. Servers return: Data (resources) and Actions (tools)
- The model incorporates this context into its response
Should you be paying attention to MCP?
Yes. Taken together, MCP hints at a shift towards more layered and modular AI architectures. While it’s still early and patterns are likely to evolve, the intent is clear: move away from ad hoc orchestration and towards a system where models, context, and tools interact through consistent, reusable interfaces.
Looking ahead, we can expect rapid evolution over the next few months as the ecosystem around MCP begins to take shape. This will likely include the emergence of MCP-compatible platforms and frameworks, and software.
More Info
If you’d like to explore MCP further, the following official and foundational are the best starting points:
Anthropic launch post
https://www.anthropic.com/news/model-context-protocol
Protocol specification (initial version)
https://modelcontextprotocol.io/specification/2024-11-05
Getting started guide
https://modelcontextprotocol.io/docs/getting-started/intro
MCP Documentation Hub
