Practitioners in the artificial intelligence field need a common standard for how we write and interact with different AI systems and processes. Anthropic’s Model Context Protocol (MCP), announced just weeks ago, aims to establish such a universal standard.
MCP addresses one of the biggest problems we currently face. When developing AI applications today, every project is unique, whether it’s how AI processes are built or how they connect with data resources. That means not only lots of development, but also a potential maintenance nightmare.
Imagine your next AI-powered application needs to integrate with multiple AI assistants and applications (e.g., Siri, VS Code, Claude Desktop, a database, or whatever hot new AI tool comes next). Each integration must be approached and maintained as a custom bespoke solution.
But as an open protocol, the Model Context Protocol proposes to tame this complexity by defining how AI applications interact and exchange data. The question then becomes, is the Model Context Protocol right for you and the AI field at large?
What Is Model Context Protocol?
MCP can be thought of as a protocol for AI capabilities. If you create a general-purpose assistant similar to Claude Desktop (in this case, the “client”), MCP allows for seamless integration with other AI applications or agents (the “servers”) built with this protocol. It sets a standard for how AI applications are built and a clear way to develop AI and agentic behavior when exchanging data across projects and applications.
Key features of the Model Context Protocol:
- MCP uses client/server workflows based on JSON-RPC.
- MCP enables developers to create specialized AI/agentic “servers” that any MCP-compatible “client” can use.
- MCP standardizes the development flow of AI-powered applications.
If MCP (or an industry protocol like it) were adopted, we could see changes like:
- Apps built from the ground up to interact with a user’s personal AI assistants and other AI-powered applications.
- Developers prioritizing design for both humans and AI.
- AI interoperability becoming standard.
- Reduced developer integration complexity and standardized development patterns.
To illustrate this, let’s build an AI agent workflow application using MCP to get a user query about the weather and autonomously respond with an answer.
An Example Model Context Protocol Application in Action
Our application consists of our host, which outlines our AI workflow and chooses an AI process to call. The AI process or client then creates a direct connection with our server that only has the tools, resources, and prompts associated with it. The returned items from the server allow the application to run the processes associated with only that server.
When a user asks a question, the application returns the results of the user query based on the server that it interacted with, as demonstrated in Figure 1 below.
In this example, a developer would only need to write the weather server once and all MCP-compatible clients could interact with it. This is visualized in Figure 2 below.
Without such a standard, the current trend is that if you want your application to work with different AI services, you need to write code for each AI application you want to integrate with, like in Figure 3 below. MCP aims to solve this problem.
Here’s what these scenarios look like side by side.
So, for our example application, MCP would potentially reduce our workload because we wouldn’t need to write three custom AI integrations. Instead, we’d need only write the weather server once, then deploy to interact with all MCP-compatible clients.
Why an AI Protocol or Standard Is Becoming Increasingly Important
There are four key challenges in modern AI development that a protocol such as MCP will address:
- Integration complexity: An AI protocol will free up developer bandwidth and budget dollars. Right now, creating a custom integration for every AI service increases development time upfront and maintenance costs on the backend, and the number of these AI services is only going to increase.
- Common design patterns: Developers will onboard faster with a shared understanding of development best practices. This will only become more important as the rise of agentic AI creates more complexity around implementation and design.
- Scalability: A standard protocol would mean developers can integrate more AI services while minimizing the complexity of managing more and more interactions.
- Future-proofing: With new AI tools and services emerging, a standardized protocol helps ensure applications can adapt to the new technologies without major rewrites.
Of course, this doesn't mean MCP or another emerging protocol will offer a magic bullet. AI practitioners will need to discern when MCP will work to their advantage, and when they should favor more traditional approaches.
When You Should Consider Using MCP
It’s important to note that since MCP is an emerging protocol/standard, it hasn’t yet been adopted by the industry (it was released on November 25, 2024). That said, certain types of projects could benefit from adopting MCP.
AI-first applications
If you're developing general-purpose AI assistants, IDE integrations, or desktop applications requiring extensive AI capabilities, MCP could streamline your development process. These applications often require integration with multiple AI services, which is precisely what MCP aims to simplify.
Scalable AI services
For projects involving distributed AI processing or systems that need to handle multiple AI workflows, MCP offers a standardized approach to manage complexity. If your service needs to scale beyond local resources, MCP’s architecture could provide the flexibility and interoperability required.
Platform integrations
MCP is particularly valuable for tools requiring AI assistant-integration, cross-platform AI applications, or services exposing AI capabilities to other applications. It offers a standardized way to interact with various AI platforms, potentially reducing development time and improving compatibility. If you're working with or planning to integrate with Claude Desktop, MCP provides integration capabilities. However, until MCP is standard, code will still need to be developed for other AI application integrations.
When Not to Use MCP
Whether or not AI practitioners adopt MCP or another standard, there will still be instances where traditional approaches to AI development are the superior choice.
Standalone Applications
Because MCP isn’t yet an established industry standard, not every application requires its approach to AI integration. Standalone applications with single-purpose AI implementations, or systems with limited scope for AI expansion, might find MCP’s implementation overhead unnecessary. Traditional development approaches might provide simpler and more direct solutions.
Simple implementations
Simple implementations, such as projects requiring basic AI functionality handled with direct API calls, might find MCP’s architecture unnecessary. Proof-of-concept applications or prototypes might achieve their goals more efficiently with straightforward implementations that don't require MCP’s full feature set or design patterns.
Risk/trend avoidance
Many AI practitioners might prefer to wait for the dust to settle. With new AI paradigms coming out so often, it’s difficult to know whether the latest thing will hold or if this is on Anthropic’s long-term roadmap.
What to Do About the Model Context Protocol Right Now
Until there’s widespread adoption of an AI protocol, it’s difficult to determine how apps should be built for interoperability with multiple external AI services. MCP or a protocol like it could be the answer to this AI interoperability, but it’s understandable why practitioners may prefer to wait until things become clearer.
With that in mind, we advise two things right now:
- If you’re creating a general purpose AI assistant, consider using MCP to leverage user-created functions and clear separation of agentic behavior.
- If you’re creating an application with clearly defined functionality (e.g., without the need for AI assistant interaction or to host agents at scale), traditional approaches may be best.
Whether MCP or something else becomes the industry standard, the future of app development likely involves considering both human users and AI assistants, and having a common way for AI systems to interact.
To learn more about Anthropic’s Model Context Protocol, check out their architecture as well as specifications for implementation. If you’re interested in seeing real-life examples, several MCP servers are being created to make connecting to resources easier. These range from servers built by Anthropic, third parties, and the community (e.g., GitHub).
In the meantime, if you need help optimizing your AI development workflows, we can help. Learn more by exploring our WillowTree’s Data & AI consulting services.
