Agents in Dialogue Part 1: MCP - The Universal Connector for AI and its Tools

The landscape of artificial intelligence is undergoing a massive change. AI agents, once largely passive assistants or "copilots," are rapidly evolving into proactive, autonomous entities capable of executing context-aware decisions and complex tasks.¹ This surge in capability and complexity brings with it a fundamental requirement: for these agents to interact effectively, not only with external systems and data sources but, increasingly, with each other.^{2, 3} As AI models become more powerful and the tasks they undertake grow in complexity, the limitations of a single, monolithic agent become apparent.³ Specialisation is emerging as a key trend, where different agents possess unique skills and knowledge. Such specialisation, however, necessitates collaboration, and meaningful collaboration relies on robust, well-defined communication the same way we know from microservices. It is in this context that the architectural foundations of traditional integration and API interaction models begin to show their limitations, particularly when dealing with agents that can reason, plan, and act with a degree of independence.¹

Without standardised communication frameworks, AI agents risk operating in silos. This fragmentation leads to significant inefficiencies, heightened integration complexity, and a fundamental inability to perform sophisticated, multi-step operations that require coordinated effort.^{2, 4} A particularly pressing challenge is enabling AI agents developed by different vendors, or using to find common ground and work together seamlessly.^{2, 3, 5}

To address these challenges, several protocols and communication paradigms have emerged, each playing a distinct role in the evolving AI ecosystem. This series of articles will explore three such pillars. In this first part, we dive into:

• Model Context Protocol (MCP): This protocol is increasingly recognised as a standard mechanism for AI applications to connect with, and make use of, external tools and services.^{6, 7} It can be seen as the "USB-C port for AI," aiming to provide a universal interface for models to access the capabilities they need.^{8, 9}

Subsequent articles will explore Agent Communication Protocols (ACPs) and the more recent Agent2Agent (A2A) Protocol.

This series aim to describe the different protocols and to provide a clear understanding of what each protocol or paradigm entails, its common applications, and, crucially, how they relate to each other form the communication backbone of increasingly sophisticated and collaborative AI systems.

This paradigm shift and the engineering of AI Native systems—focusing on scalability, adaptability, and trustworthiness—are explored weekly in our newsletter, Waves of Innovation.

MCP: The Universal Translator

Exploring MCP: What is it?

The Model Context Protocol (MCP) has rapidly emerged as a open standard, originally developed by Anthropic.^{7, 8, 9} Its primary function is to standardise the way AI applications, including programmatic agents, connect to and interact with external tools, data sources, and services.^{1, 6, 7, 8, 9, 10, 11, 12} The analogy of MCP as a "USB-C port for AI" ^{8, 9, 13} aptly captures its ambition: to offer a uniform method for AI systems to plug into various external capabilities, much like USB-C simplifies device connectivity. This approach obviates the need for bespoke, custom integrations for each new tool or data source an AI model might need to access, thereby significantly reducing development overhead and complexity.^{4, 8, 9, 12, 13} It is important to note that MCP is not designed to replace existing protocols like REST or GraphQL; rather, it operates as a distinct layer above them, providing an abstraction that unifies these underlying interfaces for AI consumption.¹

Core Purpose: Bridging AI with the Real World

The fundamental aim of MCP is to address the persistent challenge of efficiently connecting powerful AI models with external data sources and tools they require to perform effectively in real-world scenarios.^{4, 9} By establishing a common interaction pattern, MCP empowers AI applications to dynamically discover the tools available to them, inspect their functionalities, and invoke them as needed.^{1, 8, 9} This protocol facilitates robust two-way communication, enabling AI models not only to pull data from external systems (such as checking a calendar or retrieving flight information) but also to trigger actions within those systems (like rescheduling meetings or sending emails).^{8, 12}

Under the Hood: Key Architectural Concepts and Interaction Flow

MCP operates on a client-server architecture, designed to be lightweight yet powerful.

Architecture:

• MCP Hosts: These are the primary AI-powered applications that users interact with directly, such as Anthropic's Claude Desktop or AI-enhanced Integrated Development Environments (IDEs) like Cursor.^{8, 9} The host application determines which MCP servers an AI model can access.
• MCP Clients: These components act as intermediaries, maintaining dedicated, one-to-one connections between the host application and various MCP servers.^{6, 8, 9}
• MCP Servers: These are typically lightweight programs or services that expose specific capabilities from external systems. These systems can be local (e.g., files, databases on the user's machine) or remote (e.g., web APIs, cloud services).^{1, 6, 7, 8, 10, 11, 13} MCP servers essentially act as "interpreters," translating between the standardized MCP and the specific interfaces of the tools they expose.⁷
• Transport Layers: MCP supports different transport mechanisms depending on the server's location. For local servers, communication often occurs via standard input/output (STDIO).^{10, 11} For remote servers, HTTP with Server-Sent Events (SSE) is commonly used, allowing for persistent, real-time, two-way communication.^{8, 10, 11}

Primitives: MCP organises interactions around three core primitives, providing a structured way for AI models to access and utilise external context.⁹

• Tools: These are executable functions that an AI model can invoke. Examples include making API calls, querying databases, or running specific scripts.^{1, 9} MCP defines a consistent way for servers to specify the tools they offer, including their parameters and expected outputs.¹¹
• Resources: These represent structured data streams that can be provided to the AI model. This could include files, logs, API responses, or database records.⁹
• Prompts: These are reusable instruction templates designed for common workflows or tasks. They allow for more efficient and consistent interactions by providing pre-defined ways to instruct the AI model in conjunction with specific tools or resources.⁹

Interaction Flow: The communication between an MCP client (acting on behalf of an AI model) and an MCP server typically follows a sequence of steps, leveraging the JSON-RPC 2.0 protocol for structured message exchange.^{12, 13}

1. Connection and Initialization: The MCP client establishes a connection with the MCP server. An initialize message is exchanged to handshake protocol versions and server capabilities.¹³
2. Discovery: The client queries the server to discover the available tools and resources. This is often done using a tools/list method call.¹³ The server responds with a list of available capabilities, including their descriptions and input schemas.
3. LLM Choice: Based on the user's query or the ongoing task, the Large Language Model (LLM) within the host application determines which tool or resource is needed. This can be achieved through prompt engineering or the LLM's function-calling capabilities.¹³
4. Invocation: The client sends a request to the server to execute a specific tool, typically using a tools/call method, providing the tool name and necessary arguments.¹³
5. Execution: The MCP server processes the request, interacts with the underlying external system (e.g., calls an API, queries a database), and performs the requested action.^{11, 13}
6. Result Return: The server sends the result of the execution back to the client in a standardized format.^{11, 13}
7. Integration: The client integrates this result back into the AI application's context, often providing it to the LLM to inform its subsequent response or actions.¹³

Security: MCP is designed with security in mind, often adopting a "local-first" approach by default, where servers run locally unless explicitly permitted for remote use.⁹ Explicit user approval is typically required for each tool or resource access, ensuring user control over data and actions.⁹ Authentication credentials for MCP servers can be managed securely, for instance, through environment variables passed to the server process.¹⁰ Some MCP clients, implement features where the user must explicitly approve a tool's use by the AI agent.¹⁰

MCP in Action: Common Use Cases

• Intelligent Assistants and Chatbots: MCP enables these AI applications to access real-time information, such as current flight prices, weather forecasts, or product availability. They can also interact with personal or enterprise data, like CRM records, support tickets, or calendar information, to provide more contextual and useful responses.^{4, 8, 12, 14} A common example is a trip planning assistant that can check calendar availability, book flights, and send email confirmations, all orchestrated via MCP servers without needing custom integrations for each tool.⁸
• Enhanced IDEs: Intelligent code editors leverage MCP to connect the AI assistant to the developer's local environment, including file systems, version control systems (like Git), package managers, project-specific documentation, and databases. This allows the AI to have a much richer understanding of the coding context, leading to more powerful suggestions and automation capabilities.^{8, 10}
• Enterprise AI Search: MCP can power sophisticated enterprise search solutions, allowing AI agents to query across private document repositories, internal databases, and cloud storage platforms.^{12, 14, 15} For instance, Microsoft's Azure AI Agent Service integrates with MCP to facilitate knowledge retrieval from both public web data (via Bing Search) and private enterprise data (via Azure AI Search).¹⁵
• Data Analytics: AI models can connect to complex data sources via MCP to perform advanced data analysis, deriving insights that would be difficult to obtain otherwise.⁸
• Specific Server Examples: The growing MCP ecosystem includes servers for a variety of tools and services. PydanticAI, for example, offers a "Run Python" MCP server that allows AI agents to execute arbitrary Python code in a sandboxed environment.⁶ Other examples include servers for Google Drive, Slack, GitHub, PostgreSQL databases, payment platforms like Stripe, and even integrations within IDEs like JetBrains.^{9, 11, 13}

Key Proponents and Growing Adoption

MCP was initiated by Anthropic ^{7, 8, 9} and has quickly gained traction, with support and implementations emerging from various organisations and the open-source community. Microsoft has integrated MCP with its Azure AI Agent Service ¹⁵, and coding assistants like Cursor or GitHub Copilot utilise MCP extensively.¹⁰ The proliferation of community-developed MCP servers for diverse tools and services further underscores its growing adoption.^{6, 7, 11}

This rapid development and diverse adoption of MCP servers by numerous entities point towards a strong industry consensus on the necessity of such a standard. The core problem that MCP aims to solve is the one-off integrations for AI models ^{4, 7, 9}, which is a widespread and significant pain point for developers and organisations. An open protocol like MCP ^{7, 8} is attractive because it promises enhanced interoperability and a reduction in duplicated development effort. The sheer variety of example servers, ranging from general-purpose utilities like executing Python code ⁶ to specific enterprise tools like Stripe or GitHub integrations ¹¹, demonstrates MCP's adaptability across many different domains.

Furthermore, MCP represents a fundamental shift in how AI models operate. Instead of being isolated "brains" relying solely on their pre-existing training data, AI models are becoming interconnected "hubs" capable of actively leveraging a vast array of external capabilities. MCP's primary function is to facilitate this connection between LLMs and external tools and data sources.^{6, 9} This fundamentally alters their operational paradigm, allowing them to interact with and utilise external systems in real-time.¹² This ability to access and act upon current, external context makes them significantly more powerful and applicable to a much broader range of real-world tasks and challenges.

Want more like this? Further insights into AI Native systems, architecture, and strategy are provided weekly in our newsletter, [Waves of Innovation](https://re-cinq.com/monthly-report.

MCP: A Vital Link in the AI Communication Chain

The Model Context Protocol, then, serves as a crucial bridge, enabling AI agents and applications to reach beyond their inherent knowledge and interact dynamically with the vast world of external tools and data. By standardising this connectivity, MCP not only simplifies development and enhances interoperability but also empowers AI to perform more complex, context-aware tasks. However, connecting to tools is just one facet of the broader AI communication challenge.

Continue reading:

• Part 2: ACPs - The Foundational Languages of Agent Collaboration
• Part 3: A2A Protocol - Orchestrating Modern AI Agent Teams and the Collaborative Future

References:

1. How to Use Model Context Protocol the Right Way - Boomi, https://boomi.com/blog/model-context-protocol-how-to-use/
2. What is AI Agent Communication? - IBM, https://www.ibm.com/think/topics/ai-agent-communication
3. Build and manage multi-system agents with Vertex AI | Google Cloud Blog, https://cloud.google.com/blog/products/ai-machine-learning/build-and-manage-multi-system-agents-with-vertex-ai
4. Is Anthropic's Model Context Protocol Right for You? - WillowTree Apps, https://www.willowtreeapps.com/craft/is-anthropic-model-context-protocol-right-for-you
5. google/A2A: An open protocol enabling communication - GitHub, https://github.com/google/A2A
6. Model Context Protocol (MCP) - PydanticAI, https://ai.pydantic.dev/mcp/
7. Understanding the Model Context Protocol | Frontegg, https://frontegg.com/blog/model-context-protocol
8. What is Model Context Protocol (MCP)? How it simplifies AI, https://norahsakal.com/blog/mcp-vs-api-model-context-protocol-explained/
9. Model Context Protocol (MCP) Explained - Humanloop, https://humanloop.com/blog/mcp
10. Model Context Protocol - Cursor, https://docs.cursor.com/context/model-context-protocol
11. What Is the Model Context Protocol (MCP) and How It Works - Descope, https://www.descope.com/learn/post/mcp
12. Model Context Protocol (MCP), https://stytch.com/blog/model-context-protocol-introduction/
13. What you need to know about the Model Context Protocol (MCP) - Merge.dev, https://www.merge.dev/blog/model-context-protocol
14. What is Model Context Protocol? The emerging standard bridging AI and data, explained, https://www.zdnet.com/article/what-is-model-context-protocol-the-emerging-standard-bridging-ai-and-data-explained/
15. Introducing Model Context Protocol (MCP) in Azure AI Foundry: Create an MCP Server with Azure AI Agent Service - Microsoft Developer Blogs, https://devblogs.microsoft.com/foundry/integrating-azure-ai-agents-mcp/