Model Context Protocol (MCP)

The Model Context Protocol (MCP) is an open standard introduced by Anthropic in November 2024 that provides a universal interface for connecting AI models to external data sources, tools, and services. MCP follows a client-server architecture and uses JSON-RPC for communication, enabling secure, two-way connections between AI applications and the systems they need to access. By 2025, MCP became the de facto industry standard for AI tool integration, adopted by OpenAI, Google DeepMind, Microsoft, and thousands of developers worldwide.¹⁾ MCP is a standardized protocol for managing context between models and external systems, enabling reliable information exchange and tool integration as part of the Phase 5 shift from informal vocabulary to enforceable specifications for agent interoperability.²⁾ MCP is used for custom tool integration in Managed Agents, where OAuth tokens remain in a secure vault and a dedicated proxy handles authentication without exposing credentials to generated code.³⁾ MCP tools are most effective when they have access to critical company data, but this creates security and governance challenges requiring centralized audit controls and access management.⁴⁾-ai-gateway|Databricks - Governing Coding Agent Sprawl (2026]])) MCP, along with skills and plugins, is emerging as a new attack surface for security vulnerabilities in AI systems, particularly through prompt injection and unauthorized access.⁵⁾ As organizations adopt AI developer tools with expanded autonomous capabilities and access to credentials and external systems, MCP is becoming a significant security attack vector requiring careful governance and access controls.⁶⁾ The protocol enables bidirectional communication between AI agents and external systems, as demonstrated in enterprise partnerships where MCP facilitates data discovery and access across datasets, models, and execution endpoints.⁷⁾ MCP functions as an open protocol for agents referenced in composability discussions, enabling standardized communication and integration between AI agents and external systems without proprietary dependencies.⁸⁾ MCP tools are used in agent SDKs like Cursor's TypeScript SDK to enable programmatic control, repository context awareness, and automated workflows such as pull request generation.⁹⁾ MCP works best with explicit mention-based loading or subagent-scoped assignment rather than indiscriminate server attachment, allowing for more controlled and intentional tool integration.¹⁰⁾

GitHub: github.com/modelcontextprotocol
SDKs: Python, TypeScript, C#, Java
Transport: Streamable HTTP, stdio (local)

Architecture

MCP uses a client-server model where AI applications (hosts) act as MCP clients connecting to MCP servers that expose capabilities. This separation allows any AI application to connect to any tool server without custom integrations.¹¹⁾

Host: The AI application (e.g., Claude Desktop, an IDE, a custom agent)
Client: Manages the connection to an MCP server, sends requests, handles responses
Server: Exposes tools, resources, and prompts via the MCP protocol; handles data access and transformation

Communication is transport-agnostic. Local servers typically use stdio, while remote servers use Streamable HTTP. All messages follow the JSON-RPC 2.0 format.

Three Core Primitives

MCP defines three primitives that servers can expose:

1. Tools (model-controlled): Functions the AI model can invoke to perform actions. Tools are defined with JSON Schema descriptions, type hints, and parameter specifications. The model decides when to call them based on context. Examples include reading files, querying databases, or sending messages. MCP tools expose platform capabilities as standardized interfaces that AI agents can invoke, forming part of enterprise strategies like Salesforce's Headless 360 approach that enable Claude Code, Cursor, and other AI systems to interact with business systems.¹²⁾

2. Resources (application-controlled): Read-only data exposed via URIs. Resources can be direct (static content at a fixed URI) or templated (parameterized URIs). Clients handle MIME types for proper rendering. Examples include project files, configuration data, or live API responses.

3. Prompts (user-controlled): Pre-crafted instruction templates for common workflows. Prompts can accept arguments and are typically surfaced as autocomplete options in the UI. Examples include code review templates or document formatting instructions.

Python MCP Server Example

from mcp.server.fastmcp import FastMCP
import httpx
 
Create an MCP server with a name
mcp = FastMCP("weather-service")
 
@mcp.tool()
async def get_weather(city: str, units: str = "celsius") -> str:
    """Fetch current weather for a city.
 
    Args:
        city: Name of the city to look up
        units: Temperature units - celsius or fahrenheit
    """
    async with httpx.AsyncClient() as client:
        resp = await client.get(
            f"https://wttr.in/{city}",
            params={"format": "3"},
            headers={"User-Agent": "mcp-weather/1.0"},
        )
        return resp.text.strip()
 
@mcp.resource("config://settings")
def get_settings() -> str:
    """Expose server configuration as a resource."""
    return "units: celsius\nrefresh_interval: 300"
 
@mcp.prompt()
def weather_report(city: str) -> str:
    """Generate a prompt template for a detailed weather report."""
    return f"Provide a detailed weather analysis for {city}."
 
if __name__ == "__main__":
    mcp.run(transport="stdio")

Adoption and Ecosystem

MCP achieved rapid industry adoption through 2025:¹³⁾

Major adopters: OpenAI, Google DeepMind, Microsoft, Block, Apollo, Zed, Replit, Codeium, Sourcegraph
Claude integration: Claude Desktop includes native local MCP server support; Claude Code leverages MCP for enhanced coding workflows with tool integrations
Community servers: Pre-built servers exist for GitHub, Git, Postgres, Google Drive, Slack, Puppeteer, and hundreds more
Governance: In 2025, Anthropic donated MCP to the Agentic AI Foundation (AAIF) for vendor-neutral governance

The protocol complements Agent Protocol (A2A) for agent-to-agent communication, MCP handles tool connectivity while A2A handles inter-agent collaboration.

Developer Tools

Server Inspector: Browser-based tool for testing MCP servers interactively
SDK decorators: Define tools using Python/TypeScript decorators with automatic schema generation
Anthropic Skilljar course: Official training for building MCP servers