What is MCP? How AI assistants connect to tools and data

MCP stands for Model Context Protocol, an open protocol that connects AI applications to external tools and data through compatible servers. An application's MCP client discovers what a server provides and can call its tools, subject to the server's access controls and the application's permissions.

For a website owner, an MCP server can expose actions through an API even when no browser tab is open. WebMCP exposes tools in a live page instead. Supporting either protocol requires an implementation that the agent's client can use.

What Is MCP?

MCP stands for Model Context Protocol. It is an open protocol that gives AI applications a standardized way to connect to external data sources and tools. Without MCP, each AI tool builds its own integration for every service. With MCP, any AI client can talk to any MCP-compatible server through one shared protocol.

Anthropic released MCP in November 2024. Anthropic built it because its engineers kept duplicating integration code between Claude Desktop and various IDEs. Within a year, MCP reached 97 million monthly SDK downloads and support from the major AI platforms, including OpenAI, Google DeepMind, and Microsoft.

Why MCP Matters

Before MCP, every AI application had to build custom integrations for every tool it wanted to use. Want Claude to access your GitHub repositories, Slack channels, and Postgres database? Three separate integration codebases. Want ChatGPT to access the same tools? Three more. The result was an M×N problem: M applications times N tools, each requiring unique glue code.

MCP reduces this to an M+N solution. Build one MCP server for your tool, and every MCP-compatible client can use it. Build one MCP client, and it talks to every MCP server. USB works the same way: with a standard interface, each side implements it once.

How MCP Works

MCP uses a client-server architecture built on JSON-RPC 2.0, inspired by the Language Server Protocol (LSP) that standardized IDE tooling. If you've worked with LSP, the structure will feel familiar. The protocol defines three roles:

• Hosts: AI applications that initiate connections (Claude Desktop, Cursor, VS Code)
• Clients: Protocol connectors within the host that maintain 1:1 connections with servers
• Servers: Services that expose tools, data, and capabilities to AI models

A host application contains one or more MCP clients, each connected to a different MCP server. Ask Claude to "check my GitHub issues" and the host routes that request through its MCP client to the GitHub MCP server. That server executes the action and returns the result.

Server Primitives: Tools, Resources, and Prompts

MCP servers expose three types of primitives:

• Tools: Functions the AI model can call to take actions (search a database, send an email, create a file). The model decides when and how to use them.
• Resources: Data the server makes available for context (files, database records, API responses). These are read-only and used to enrich the model's understanding.
• Prompts: Reusable prompt templates and workflows that the server offers. Users can select these to structure their interactions.

Clients can also offer capabilities to servers:

• Sampling: Lets servers request LLM completions through the client, which allows recursive agent workflows
• Roots: Lets servers query the filesystem or URI boundaries they should operate within
• Elicitation: Lets servers ask users for additional information during execution

Transport Types

MCP defines two standard transport mechanisms. Your deployment model decides which one to use.

stdio: Local Process Communication

In the stdio transport, the client launches the MCP server as a subprocess. Communication happens over standard input and output. It is the simplest transport and works well for local tools such as file systems, databases, and development utilities.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/projects"]
    }
  }
}

Streamable HTTP: Remote Server Communication

The Streamable HTTP transport replaced the earlier HTTP+SSE transport in the 2025-03-26 spec revision. It enables remote MCP servers that can handle multiple client connections over the network. The server exposes a single HTTP endpoint that accepts POST and GET requests, with optional Server-Sent Events (SSE) for streaming responses.

This makes MCP relevant for web platforms and SaaS products. Instead of requiring users to run a local process, you host an MCP server at a URL like https://api.example.com/mcp and any compatible client can connect remotely.

Streamable HTTP adds:

• Session management via Mcp-Session-Id headers for stateful interactions
• Resumability through SSE event IDs, so clients can reconnect after a dropped connection without losing messages
• Multiple concurrent connections from different clients to the same server
• Security requirements including Origin header validation to prevent DNS rebinding attacks

Discovery: /.well-known/mcp.json

For remote MCP servers, discovery is the first problem you need to solve. How does a client know what MCP servers a domain offers? The proposed approach is a well-known discovery endpoint at /.well-known/mcp.json that lists available MCP servers and their endpoints.

{
  "version": "1.0",
  "servers": [
    {
      "name": "primary",
      "description": "Main API server for example.com",
      "endpoint": "https://mcp.example.com/v1"
    },
    {
      "name": "analytics",
      "description": "Analytics data access",
      "endpoint": "https://mcp.example.com/analytics"
    }
  ]
}

This follows the same idea as robots.txt for crawlers and /.well-known/openid-configuration for OAuth: clients find available services without manual configuration. Add proper CORS headers (Access-Control-Allow-Origin: *) to support browser-based clients.

Who Backs MCP?

MCP is no longer a single-company project. On December 9, 2025, exactly one year after launch, Anthropic donated MCP to the Agentic AI Foundation (AAIF), a directed fund under the Linux Foundation. The AAIF was co-founded by Anthropic, Block, and OpenAI, with support from Google, Microsoft, AWS, Cloudflare, and Bloomberg.

Alongside MCP, the AAIF governs two other founding projects:

• Goose (by Block): an open-source AI agent framework
• AGENTS.md (by OpenAI): a standard for describing agent capabilities in repositories

The agents.json specification covers a related topic. It gives websites a standardized way to advertise their AI agent capabilities and supported protocols.

MCP now sits under the Linux Foundation, which also hosts Linux, Kubernetes, and PyTorch. No single company controls its direction.

Current Adoption

RedMonk called MCP "the fastest-adopted standard" it has ever tracked, and described an S-curve adoption pattern similar to Docker's rapid market saturation. The table lists the main milestones:

Today, most major AI coding tools and assistants support MCP:

• Claude Desktop & Claude Code: Anthropic's own applications, MCP-native from day one
• ChatGPT: OpenAI added full MCP support in March 2025
• Cursor: MCP integration for tool use and context
• VS Code + GitHub Copilot: Agent mode uses MCP to invoke external tools during coding sessions
• Windsurf (Codeium): Full MCP server support for AI coding workflows
• Gemini: Google DeepMind confirmed MCP support for contextually aware agent interactions
• Microsoft Copilot: MCP support across the Copilot ecosystem
• Zed, Cline, Replit, Continue.dev: Other developer tools with MCP support

The MCP Ecosystem

The ecosystem around MCP has grown fast. Over 10,000 active MCP servers are publicly available, covering developer tools, enterprise data platforms, and more. The community maintains multiple registries and directories where you can find servers for your use case.

Popular MCP servers cover:

• Developer tools: GitHub, GitLab, Jira, Linear, Sentry
• Data & databases: PostgreSQL, MongoDB, Snowflake, BigQuery
• Productivity: Google Drive, Slack, Notion, Confluence
• Infrastructure: AWS, Cloudflare, Docker, Kubernetes
• Web & search: Brave Search, Firecrawl, Puppeteer, Playwright
• Design: Figma, Blender

The official SDKs are available in TypeScript and Python, with community SDKs for Go, Rust, Java, C#, Ruby, and more. The TypeScript SDK is maintained at @modelcontextprotocol/sdk and the Python SDK at mcp (with the high-level FastMCP framework for faster development).

What's Evolving in the MCP Spec

The November 2025 specification (version 2025-11-25) added several features:

• Async Tasks: Durable request tracking with polling and deferred result retrieval, so long-running operations do not need an open connection
• URL Mode Elicitation: Servers can send users to a browser URL for sensitive flows like OAuth authentication or payment processing, keeping credentials secure
• Enhanced OAuth: OpenID Connect Discovery support, incremental scope consent, and Client ID Metadata Documents that remove the need for per-server registration
• Server Icons: Servers can expose icon metadata for tools, resources, and prompts, improving discoverability in client UIs
• Tool Calling in Sampling: Servers can include tool definitions when requesting LLM completions, which allows more complex agentic workflows
• Formalized Governance: Working groups, interest groups, SDK tiering, and community communication guidelines

The community is working on standardized server discovery via /.well-known/mcp.json, better enterprise authorization patterns, and deeper integration with other agentic protocols.

How to Implement MCP

With the official SDKs, an MCP server takes little code. The following minimal example exposes one tool to an AI assistant.

Building an MCP Server in TypeScript

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "weather",
  version: "1.0.0"
});

server.tool(
  "get-weather",
  "Get current weather for a city",
  { city: z.string().describe("City name") },
  async ({ city }) => {
    const response = await fetch(
      `https://api.weather.example.com/current?city=${city}`
    );
    const data = await response.json();
    return {
      content: [{
        type: "text",
        text: `Weather in ${city}: ${data.temperature}°C, ${data.condition}`
      }]
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Building an MCP Server in Python

The Python SDK includes FastMCP, a high-level framework that shortens the code further:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("weather")

@mcp.tool()
async def get_weather(city: str) -> str:
    """Get current weather for a city."""
    response = await fetch_weather(city)
    return f"Weather in {city}: {response.temperature}°C, {response.condition}"

if __name__ == "__main__":
    mcp.run()

Adding MCP Discovery to Your Website

If you host a remote MCP server, add a discovery endpoint so clients can find it:

{
  "version": "1.0",
  "servers": [
    {
      "name": "your-platform",
      "description": "Access your platform data and tools via MCP",
      "endpoint": "https://api.yourplatform.com/mcp"
    }
  ]
}

Serve this file at /.well-known/mcp.json with the proper CORS headers. Clients that support discovery can then find your server without manual configuration.

What Implementing MCP Means for Your Platform

Adding MCP support to your platform or API has four main benefits:

MCP vs A2A: How They Complement Each Other

Google's Agent-to-Agent (A2A) protocol is another standard in the agentic AI space. MCP and A2A do not compete. They solve different problems at different layers.

In practice, an agentic system can use both. Each agent uses MCP to connect to its tools and data sources (the vertical axis), and A2A lets agents discover and collaborate with each other (the horizontal axis).

MCP vs WebMCP: Server-Side Meets the Browser

MCP connects AI models to backend tools and data. WebMCP does the same thing, but for the browser. WebMCP (Web Model Context Protocol) is a W3C proposal co-authored by Google and Microsoft that lets websites expose their functionality as structured tools. AI agents can discover and invoke them directly in the browser, without a backend.

Both protocols work the same way. You define tools with names, descriptions, and input schemas, and AI agents call them.

MCP gives AI agents access to your backend (query a database, call an API, manage infrastructure). WebMCP gives them access to your frontend (search your product catalog, fill out a booking form, check availability). A travel site might use MCP to expose its booking API to AI assistants, and WebMCP to let browser-based agents search flights and complete bookings directly in the UI.

The protocols complement each other. If you implement both, AI agents can reach your platform through a backend integration or through the browser.

Who Should Implement MCP?

Any organization that exposes data or functionality can offer an MCP server:

• API providers: If you have a REST or GraphQL API, wrapping it as an MCP server makes your service accessible to any MCP-compatible AI assistant. Stripe, Twilio, and similar platforms are natural MCP candidates.
• Data platforms: Databases, analytics tools, and data warehouses can expose query interfaces through MCP, letting AI models access structured data directly.
• SaaS products: Any product with an API can offer an MCP server alongside its REST endpoints. Customers get access from their AI assistants without writing integration code.
• Developer tools: CI/CD platforms, monitoring tools, and infrastructure services can expose their capabilities through MCP for AI-assisted DevOps workflows.
• Content platforms: CMS systems, documentation platforms, and knowledge bases can expose content as MCP resources, making their data directly available to AI agents. Understanding how AI models like Claude select sources can help you structure these resources effectively.
• Enterprise systems: CRMs, ERPs, and internal tools can use MCP to give AI assistants controlled access to business data, with OAuth and permission scoping built into the protocol.

Getting Started with MCP

To make your platform MCP-compatible, follow these steps:

1. Choose your SDK: Use the official TypeScript SDK or Python SDK (with FastMCP for rapid development).
2. Define your tools: Identify the key actions and data queries your platform offers. Each API endpoint is a potential MCP tool.
3. Choose a transport: Use stdio for local dev tools and Streamable HTTP for remote or production servers.
4. Implement authentication: For remote servers, use OAuth 2.0 flows from the MCP authorization spec. The November 2025 update added Client ID Metadata Documents to simplify registration.
5. Add discovery: Serve a /.well-known/mcp.json file listing your MCP server endpoints.
6. Test with real clients: Connect your server to Claude Desktop, Cursor, or VS Code to verify it works across different MCP hosts.

Where MCP Stands Today

In just over a year, MCP went from an internal Anthropic experiment to a protocol that OpenAI, Google, Microsoft, and others support, under Linux Foundation governance. It fits the broader shift from traditional SEO toward AI Engine Optimization , where making your platform machine-readable matters as much as making it human-readable.

For platform builders, MCP is now one of the main ways AI assistants connect to your tools. The TypeScript and Python examples above show how small a first server can be.

Sources

• Model Context Protocol - Official Documentation - Protocol overview, guides, and specification
• MCP Specification 2025-11-25 - Current protocol specification with architecture, features, and security model
• MCP Transports Specification - stdio and Streamable HTTP transport details
• MCP Specification Changelog - Changes in the November 2025 specification release
• Introducing the Model Context Protocol - Anthropic - Original announcement from November 2024
• Donating MCP to the Agentic AI Foundation - Anthropic - December 2025 donation to the Linux Foundation
• Agentic AI Foundation Announcement - Linux Foundation - AAIF formation with MCP, Goose, and AGENTS.md
• A Year of MCP: From Internal Experiment to Industry Standard - Pento - Timeline of MCP's first year
• .well-known/mcp Discovery Discussion - GitHub - Community discussion on MCP server discovery format
• MCP TypeScript SDK - GitHub - Official TypeScript SDK for building MCP servers and clients
• MCP Python SDK - GitHub - Official Python SDK with FastMCP framework
• MCP 2025-11-25 Spec Update - WorkOS - Analysis of async tasks, OAuth improvements, and enterprise features
• MCP vs A2A Clearly Explained - Clarifai - Comparison of MCP and A2A protocols
• MCP Joins the Linux Foundation - GitHub Blog - GitHub's perspective on MCP governance transition