What is MCP? — Model Context Protocol Explained (2026)

Definition

MCP (Model Context Protocol) is an open standard created by Anthropic for connecting AI models to external tools, data sources, and APIs. It defines a standardized communication protocol between an AI agent (the client) and a tool server (the provider), enabling agents to discover available tools, understand their capabilities, and invoke them with structured inputs and outputs.

In simpler terms: MCP is the language AI agents speak when they want to use your API. Just as HTTP standardized how web browsers talk to web servers, MCP standardizes how AI agents talk to tool providers. Without MCP, every agent-API integration requires custom code. With MCP, any compatible agent can connect to any MCP server using the same protocol.

MCP was publicly released by Anthropic in late 2024 and has since been adopted by a growing ecosystem of AI platforms, developer tools, and API providers. As of 2026, it is the most widely supported protocol for AI agent tool use.

Why MCP was created

Before MCP, connecting AI agents to external tools required custom integrations for every agent-API pair. Each AI platform had its own approach: OpenAI used function calling with JSON schemas, LangChain had its own tool abstraction, and other frameworks invented their own formats. This created an N-times-M integration problem — N agents times M tools, each requiring custom glue code.

MCP solves this by introducing a single protocol that both agents and tools can implement. An API provider builds one MCP server, and it works with every MCP-compatible agent. An agent framework implements MCP client support once, and it gains access to every MCP server in the ecosystem. This reduces the integration problem from N-times-M to N-plus-M.

The need for standardization became acute as AI agents moved from simple question-answering to autonomous task execution. Agents in 2026 need to search the web, manage calendars, query databases, send emails, deploy code, and interact with hundreds of other services. Without a standard protocol, this ecosystem cannot scale. MCP provides the foundation for scalable, interoperable AI agent tool use.

How MCP works

MCP follows a client-server architecture with three primary components:

The communication flow works like this:

User: "What tasks are on the Engineering board?"

1. Host receives user message
2. Host sends message to AI model (e.g., Claude)
3. Model decides it needs the "listTasks" tool
4. MCP Client sends tool invocation to MCP Server:
   {
     "method": "tools/call",
     "params": {
       "name": "listTasks",
       "arguments": {
         "boardId": "eng-board-001",
         "status": "open"
       }
     }
   }
5. MCP Server translates to API call:
   GET https://api.projectboard.io/v2/boards/eng-board-001/tasks?status=open
6. MCP Server returns structured result to Client
7. Model formats result for the user
8. Host displays: "Here are 12 open tasks on the Engineering board..."

MCP supports two transport mechanisms: stdio (standard input/output, for local servers running as child processes) and SSE (Server-Sent Events over HTTP, for remote servers). The stdio transport is simpler and more common for local development tools, while SSE enables cloud-hosted MCP servers that any client can connect to over the network.

MCP server config example

To connect an MCP-compatible client (like Claude Desktop) to an MCP server, you use a configuration file that specifies which servers to connect to and how. Here is a realistic example:

{
  "mcpServers": {
    "projectboard": {
      "command": "npx",
      "args": ["-y", "@projectboard/mcp-server"],
      "env": {
        "PROJECTBOARD_API_KEY": "pb_live_abc123..."
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_xxxxxxxxxxxx"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost:5432/mydb"
      }
    }
  }
}

Each entry in mcpServers defines a server connection. The command and args fields specify how to start the server process (using stdio transport). The env field passes environment variables like API keys securely.

For remote servers using SSE transport, the config uses a URL instead:

{
  "mcpServers": {
    "projectboard-remote": {
      "url": "https://mcp.projectboard.io/sse",
      "headers": {
        "Authorization": "Bearer pb_live_abc123..."
      }
    }
  }
}

Key MCP concepts

MCP defines four core primitives that servers can expose to clients:

MCP vs REST APIs

MCP does not replace REST APIs. It is a protocol layer that sits on top of your existing API, adding standardized discovery and invocation for AI agents.

A REST API defines endpoints, request/response formats, and authentication. It is designed for programmatic access by software developers who write code to call specific endpoints. MCP adds a layer that lets AI agents use those same endpoints without custom integration code.

For a deeper exploration of how MCP changes the API integration landscape, see The Future of APIs: From Developers to AI Agents.

MCP vs agent.json

agent.json and MCP serve different but complementary roles in the AI agent ecosystem:

agent.json describes capabilities. It is a static file that tells agents what your API can do, what actions are available, what inputs each action requires, and when to use each action. It is a specification format — a machine-readable description of your API's surface area.

MCP enables connection. It is a runtime protocol that defines how an agent communicates with a tool server to invoke actions, receive results, and access resources. It is the wire protocol for AI agent tool use.

In practice, these work together: an agent might discover your API through your agent.json file, then connect to it via an MCP server to actually use it. Elba generates both from a single source of truth — your API definition — ensuring they stay consistent.

Who supports MCP

MCP was created by Anthropic and is natively supported by Claude across all interfaces — Claude Desktop, the Claude API, and Claude-powered applications. Since its release, adoption has expanded significantly:

How to create an MCP config for your API

There are two paths to making your API available via MCP:

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: "projectboard",
  version: "1.0.0",
});

server.tool(
  "createTask",
  "Create a new task in a project board",
  {
    boardId: z.string().describe("ID of the board"),
    title: z.string().describe("Task title"),
    priority: z.enum(["low", "medium", "high", "urgent"]).optional(),
  },
  async ({ boardId, title, priority }) => {
    const response = await fetch("https://api.projectboard.io/v2/tasks", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${process.env.PROJECTBOARD_API_KEY}`,
      },
      body: JSON.stringify({ boardId, title, priority }),
    });
    const task = await response.json();
    return { content: [{ type: "text", text: JSON.stringify(task) }] };
  }
);

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

For a comprehensive overview of agent-native documentation approaches, see Best API Documentation for AI Agents.

Frequently asked questions

Further reading

For a deeper technical walkthrough of MCP with additional examples, read our blog post MCP Explained: Model Context Protocol for API Integration. For integration details and setup guides, see the MCP documentation.

Related topics: What is agent.json? · What is llms.txt? · How to Make Your API Usable by AI Agents