Understanding MCP: A Developer's Perspective

Anthropic Model Context Protocol

As developers, we often jump on the latest technology wave, sometimes for good reason, sometimes just because it's the new shiny thing. The Model Context Protocol (MCP) is generating considerable enthusiasm in AI development circles. But is it truly the game-changer it's being portrayed as? Let me share my thoughts after exploring MCP and comparing it to existing solutions.

What is MCP and Why the Hype?

MCP is an open standard, introduced by Anthropic, for connecting AI systems with data sources. It replaces fragmented approaches for instructing LLMs to call external tools or data sources with a single, standardized protocol compatible across various LLMs.

The best way to grasp the idea is by hypothesizing a scenario.

Imagine asking ChatGPT[*] to read your emails and create a PowerPoint presentation with two graphs:

1. A histogram of the most frequent senders

2. A word map of the most frequent words in the received emails
   

MCP create a standard for LLMs (or better AI tools like ChatGPT) for interrogating external APIs like your Gmail mailbox and your PowerPoint app.

For developers, this is no novelty. This type of behaviour has been possible since the introduction of function calling in 2023. Frameworks like LangChain have facilitated its integrations across different models pretty successfully. For example, the OpenAPIToolkit by LangChain allows you to transform any OpenAPI specs YAML file into a series of tools callable by any LLMs. This is no different from what MCP proposes, but the difference resides in the fact that MCP is a Protocol, not a framework, and if adopted by everyone, will be at the core of the new Agents era dictating how agents communicate with each other.

Ok, it is a protocol, but what is new?

MCP defines some specifications: it uses JSON-RPC 2.0 and it allows 2-way communication.

By following a simple architecture, developers can:

• Expose data through MCP servers

• Build AI applications (MCP clients) connecting to these servers

Unlike OpenAPI specifications or other conventional approaches, MCP shifts the discovery and integration of tools to runtime rather than design time[**]. This means the developer of the MCP Host (e.g., ChatGPT) does not need to write custom integration code for each new tool. Instead, the responsibility falls on the creator of the MCP tool/server. The LLM can then dynamically understand and interact with available tools by reading their descriptions, eliminating a major integration challenge.

Additional advantages of MCP are prompts, resources, and sampling. Sampling, in particular, is what enables two-way communication, allowing the MCP server to request text completion and reasoning from the MCP Host.

While the novelties mentioned above clearly have merit, they are not what makes MCP truly important. I believe MCP still lacks several key components, such as OAuth integration. Nevertheless, MCP's significance lies elsewhere: just as the dawn of the internet era led to new protocols designed to standardize client-server communication (such as HTTP), MCP aims to standardize agent-to-agent and agent-to-human communication. If, in the future, a leaner or better-designed protocol emerges, it could potentially replace MCP, much like RESTful APIs replaced SOAP due to their simplicity and efficiency during the evolution of web services.

Tech-Savvy Adoption vs. Mass Democratization

After experimenting with MCP servers, I was not blown away as a developer. However, I must recognize that it has generated a lot of enthusiasm, particularly in the LinkedIn and Twitter/X communities. This is, in my opinion, because the major value has been brought to tech-savvy people, very active on both platforms, who are not necessarily developers but who like to automate their tasks to increase productivity.

I've seen an example of a Reddit user creating an impressive workflow by connecting various tools via MCP:

• ExaSearch for research

• UseScraper for web data

• McpObsidian for note integration

• Server-wp-mcp for WordPress documentation

• Stability-AI for image generation

This user created a system that can fetch blog ideas from Obsidian, apply writing styles from WordPress, and conduct research using ExaSearch. All through a chat interface.

This has been possible because, thanks to the introduction of MCP and new frameworks like FastMCP, creating an MCP server requires only a few lines of code:

from fastmcp import FastMCP

from fastmcp import FastMCP


mcp = FastMCP("Demo 🚀")


@mcp.tool()
def add(a: int, b: int) -> int:
   """Add two numbers"""
   return a + b

So in the past weeks, we've witnessed a fast proliferation of new tools that can be integrated with minimal code to Claude Desktop[***]. Many curated lists of MCP servers have popped up (such as awesome-mcp-servers), along with platforms like Smithery that facilitate installations.

What's Holding Back Mass Adoption?

Setting up a workflow similar to the Reddit user's still involves minimal coding or configuration, making MCP not fully user-friendly yet, and this is likely a key barrier to its widespread adoption.

The authentication problem is a significant barrier that MCP doesn't yet address. Without OAuth implementation, users need to handle authentication for each service separately using API Keys, creating friction that limits adoption beyond tech enthusiasts. Normal users don't know how to obtain API keys... They just want to sign in with Google or email and password.

What's In It for Developers?

For developers already using function calling, MCP might not feel revolutionary yet. However, I see potential for transformative workflows:

1. Imagine waking up and asking about your tasks for the day (with your agent reading Discord, to-do lists, and email), then telling Cursor to handle them. It only pings your Apple Watch when critical decisions are needed, allowing you to focus on studying new technologies and only be questioned for important decision-making.

   
   

2. An agent activated by incoming emails could handle simple responses automatically, only requesting approval for complex cases.

   
   

3. When receiving a production error log in Slack, you could use voice control to access and filter Azure logs, investigate the database with SQL queries, find the error, and instruct Cursor to implement the solution.

The OS Advantage

In these examples, Cursor acts as just another tool or agent to be invoked, and there will likely be a supervisor agent orchestrating the overall process. This supervisor agent would use MCP to communicate both with you and the other agents, though this isn't yet certain.

I suspect OS-level AI assistants such as Apple Intelligence or Microsoft Copilot might ultimately dominate this space if they make the right strategic moves. Whether they will adopt MCP for communication remains unclear.

Spoiler: Microsoft is already encouraging developers to build agents within its ecosystem (more on this in the next article).

These OS-level assistants have inherent advantages, including seamless access to apps across interconnected devices, better integration with device-specific LLMs, biometric authentication, device trust, and other features that could prove decisive.

Conclusion: Beyond the Hype

The Model Context Protocol (MCP) introduced by Anthropic represents a promising step toward standardizing communication between AI agents and external tools, shifting integration from design-time to runtime and enabling dynamic two-way interactions. While MCP simplifies tool integration and has rapidly gained traction among tech-savvy enthusiasts due to its ease of use, it currently lacks critical features like OAuth authentication, limiting its broader adoption.

Although not revolutionary for developers already familiar with existing frameworks, MCP's true potential lies in its capacity to democratize complex workflows and automation tasks for non-developers. However, ultimate mass adoption may hinge on whether major OS-level AI assistants incorporate MCP or develop competing standards, potentially determining the protocol's long-term relevance and success.

___________________________

[*]: ChatGPT has not implemented MCP yet. Using it as an example because of its popularity.

[**]: Theoretically, with OpenAPIToolkit we could also avoid re-design by the developer by using a hosted and updatable YAML file instead of a static YAML. However, it would still require restarting the application and would not be as live and reactive as MCP.

[***]: Open-source alternatives like 5ire are also emerging in this space, further democratizing access to these capabilities.