Model Context Protocol MCP

From: aidotengineer

Model Context Protocol (MCP) is an open-source, standardized protocol designed to connect AI with the external world, enabling models to interact with tools and access context beyond their immediate environment [02:34:21]. It addresses the “copy and paste hell” that users and AI products faced when AI was not connected to the rest of the world [02:30:07].

Origin and Motivation

The concept of MCP arose in mid-2024 from David and Justin, the co-creators at Anthropic, who observed the constant need to copy and paste context from external sources like Slack messages or error logs (e.g., Sentry) into a model’s context window [02:33:09]. This led to the fundamental question: How can a model “climb out of its box,” reach into the real world, and retrieve necessary context and actions? [02:33:52]

The core idea was to address model agency – giving models the ability to interact with the outside world [02:34:06]. For this to scale, it had to be an open-source, standardized protocol [02:34:21]. This was crucial because proprietary ecosystems require complex business development and alignment on interfaces for integration [02:34:42]. As reasoning models improved and tool calling became more effective, it was essential to allow wider participation in this ecosystem [02:35:12].

A small internal “tiger team” at Anthropic developed MCP, which was launched during the company’s hack week in November 2024 [02:35:28]. This internal launch went viral, with engineers automating workflows using MCPs [02:35:41], ultimately leading to its open-source release in November 2024 [02:36:08].

Technical Structure and Features

The MCP specification includes:

• JSON RPC Specification: A standard way of sending messages and communicating between context providers and code interacting with models [02:52:38].
• Global Transport Standard: Deals with aspects like streamable HTTP, OAuth 2.1, and session management for universal communication [02:53:02].
• Tools: Reflect actions and are mostly easy to map to function calling [03:07:17]. While powerful, too many tools or tools from too many domains can confuse AI [03:07:52].
• Resources: Provide a semantic layer to return references to files or data, rather than large direct files, allowing LLMs to follow up on them or users to act upon them [03:10:30].
• Prompts: Used in the protocol to guide model behavior [03:05:28].
• Sampling: Allows a server to request LLM completions from the client [03:11:55]. This is a progressive enhancement for tasks like summarizing resources or formatting web content [03:12:26].
• Elicitation: Enables servers to ask for more information from end-users, for instance, to clarify “best flight” as “cheapest” or “fastest” [02:42:30]. This adds more statefulness to tools [03:16:30].
• Dynamic Discovery: Allows a server to dynamically offer new tools to the client, depending on context (e.g., a “battle” tool appearing only when a monster is present in a game) [03:09:16].
• Roots: Similar to dynamic discovery, new roots can be sent as the client’s workspace changes [03:12:49].

Adoption and Impact

Initially, there was confusion about MCP’s purpose and its necessity given existing tool-calling capabilities [02:36:38]. The turning point for widespread adoption occurred when Cursor adopted MCP, followed by other coding tools like VS Code and Sourcegraph [02:37:18]. More recently, major AI labs including Google, Microsoft, and OpenAI have also adopted MCP, making it increasingly standard [02:37:50].

As an industry standard, MCP simplifies development by providing a single approach for engineers, allowing them to focus on unique problems rather than plumbing integrations [02:54:30]. Its design preemptively solves common problems, such as integrating different billing models or managing token limits through sampling primitives [02:55:54].

For organizations, MCP facilitates building integrations once and using them anywhere, promoting portability of credentials and centralized auditing [02:57:42]. For example, Anthropic uses an “MCP gateway” as shared infrastructure to provide a single entry point for various services, handling credential management and rate limiting [02:58:07].

The rise of MCP signifies a fundamental shift in the internet’s economy, where tool calls are becoming the “new clicks” [02:31:05].

Challenges and Considerations

Despite its benefits, integrating AI with applications using Model Context Protocol MCP presents challenges:

• OAUTH 2.1 Implementation: While standard, some developers find it complex, with limited support among providers [03:25:10]. However, it allows for enterprise-grade authorization [03:14:47].
• API Wrapper Syndrome: A common mistake is simply wrapping existing APIs as MCP tools. This leads to poor results because models struggle to reason about giant, undifferentiated JSON payloads [03:25:57]. MCP tools should be designed with the model and end-user in mind, treating the model as a user and focusing on clear, structured output (e.g., Markdown) [02:46:04].
• Client Support: Not all clients fully support the MCP specification, leading to inconsistencies. Continuous updates and feedback from the community are crucial to close this “interoperability gap” [03:17:05].
• Debugging and Logging: Early development can be challenging due to difficulties in debugging and logging MCP server interactions [03:13:17]. Tools like inspector and VS Code’s dev mode are being developed to improve this [02:42:14].
• Cost Management: Since the client often bears the cost, developers need to be mindful of token usage when designing tools [03:31:52].
• Security: Deploying random MCP tools in an organization is risky due to prompt injection vulnerabilities and the potential for exfiltrating private data [03:28:40]. Strong security, observability, and auditing measures are essential [02:48:25].

Future Outlook

The future developments and roadmap for mCP are focused on enhancing agent experience and simplifying server building:

• Agent Experience: Focus on features like elicitation to allow servers to request more information from users [02:42:24].
• Registry API: Will make it easier for models to find MCPs that weren’t initially provided, furthering model agency [02:43:08].
• Developer Experience: Continued efforts to provide open-source examples and best practices for building MCPs [02:43:28].
• Server Building Simplification: More tools for hosting, testing, and evaluation of MCP servers, for both enterprises and indie developers [02:46:52].
• Automated MCP Server Generation: A “moonshot” goal where models might eventually be able to write their own MCPs dynamically [02:47:40].
• Openness and Governance: Ensuring MCP remains an open standard forever, with ongoing investment in its governance [02:43:54].

The vision for MCP is to enable rich, stateful interactions between agents, leveraging the full specification beyond just simple tool calls [03:07:09]. This includes using resources for semantic layers, dynamic discovery, and sampling for progressive enhancements [03:10:47]. The ultimate goal is to enable the development of “action-oriented, context-aware, semantic-aware servers” using the full potential of the protocol [03:17:23].