Why are MCPs needed at all?

by

Summary

The Model-Context-Protocol (MCP) is a new protocol that aims to standardize how agentic software invokes other tooling within systems, reducing the need for multiple connectors. However, with existing solutions like OpenAPI, WSDLs, and WADL, the question arises: why is MCP needed at all? This article explores the root cause of the need for MCP, its real-world impact, and how senior engineers approach this problem.

Root Cause

The root cause of the need for MCP lies in the limitations of existing solutions, including:

  • Lack of standardization: Existing solutions have different strengths and weaknesses, leading to a fragmented landscape.
  • Insufficient expressiveness: Current solutions may not be able to capture the complexity of modern systems and tooling.
  • Inadequate support for agentic software: Existing solutions are often designed for traditional software interactions, not agentic software that requires more dynamic and flexible interactions.

Why This Happens in Real Systems

In real-world systems, the need for MCP arises from the complexity of tooling interactions and the diversity of agentic software. As systems grow and evolve, the number of tooling interactions increases, making it difficult to manage and maintain multiple connectors. Additionally, agentic software requires more flexible and dynamic interactions, which existing solutions may not be able to provide.

Real-World Impact

The lack of a standardized protocol like MCP can have significant real-world impacts, including:

  • Increased development time and cost: Developing and maintaining multiple connectors can be time-consuming and costly.
  • Reduced system reliability: The complexity of multiple connectors can lead to errors and system failures.
  • Limited scalability: The lack of standardization can limit the ability to scale systems and add new tooling.

Example or Code

import requests

# Example of using OpenAPI to invoke a tool
response = requests.get('https://example.com/api/tool')
print(response.json())

This example illustrates how OpenAPI can be used to invoke a tool, but it does not demonstrate the limitations of OpenAPI or the need for MCP.

How Senior Engineers Fix It

Senior engineers fix this problem by:

  • Evaluating existing solutions: Assessing the strengths and weaknesses of existing solutions like OpenAPI, WSDLs, and WADL.
  • Designing a standardized protocol: Creating a protocol like MCP that can standardize tooling interactions and support agentic software.
  • Implementing and testing: Implementing and testing the protocol to ensure it meets the needs of the system and tooling.

Why Juniors Miss It

Juniors may miss the need for MCP because they:

  • Lack experience with complex systems: Juniors may not have worked with large, complex systems that require multiple tooling interactions.
  • Are familiar with existing solutions: Juniors may be familiar with existing solutions like OpenAPI and not see the need for a new protocol.
  • Do not consider the long-term implications: Juniors may not consider the long-term implications of using existing solutions and the potential benefits of a standardized protocol like MCP.