What is MCP? A technical primer for product and platform teams

The Model Context Protocol (MCP) is an open protocol that standardizes how AI applications connect to external tools and data. Build one MCP server for your product or system, and every compliant client (Claude, ChatGPT, Cursor, VS Code, your own agents) can use it. This primer covers what’s in the protocol and what it means for a product or platform roadmap.

The problem MCP solves

Before MCP, connecting an assistant to a system meant a bespoke integration: one for each assistant, multiplied by one for each system. Ten assistants and twenty systems meant up to two hundred integrations, each with its own auth, schema conventions, and failure modes, and each one breaking when either side changed.

MCP turns that N×M problem into N+M. Systems expose capabilities once, as an MCP server. Assistants implement the client side once. Anything that speaks the protocol can talk to anything else that does.

Hosts, clients, and servers

The host is the AI application a person uses: Claude, ChatGPT, Cursor, or an agent you built. The host runs one client per connection, and each client talks to exactly one server, which exposes capabilities from your product or system.

Messages are JSON-RPC 2.0. When a connection opens, client and server negotiate capabilities, so each side knows what the other supports before any real work happens. That negotiation is what lets the protocol evolve without breaking older clients.

What a server exposes

A server offers three kinds of primitives:

• Tools are actions the model decides to call, each with a name, a description, and a JSON Schema for its inputs. Most of the value, and most of the design work, lives here.
• Resources are context the application can read, addressed by URI: files, records, documents.
• Prompts are reusable templates a user invokes deliberately, like a slash command.

The traffic isn’t one-way. Clients can offer features back to servers: sampling (asking the host’s model to generate something), elicitation (asking the user for input or confirmation mid-task), and roots (telling the server which locations it may work in).

Here’s what a well-designed tool looks like in a tools/list response:

{
  "tools": [{
    "name": "find_tickets",
    "description": "Search support tickets by text, status, or assignee. Returns up to 20 matches with IDs to pass to get_ticket_context.",
    "inputSchema": {
      "type": "object",
      "properties": {
        "query": { "type": "string" },
        "status": { "type": "string", "enum": ["open", "pending", "closed"] },
        "assignee": { "type": "string", "description": "Email of the assignee" }
      },
      "required": ["query"]
    }
  }]
}

Transports

MCP defines two standard transports. stdio runs the server as a local process and suits developer tools on a single machine. Streamable HTTP runs the server remotely behind one HTTP endpoint, with optional server-sent events for streaming. Remote is what SaaS connectors and enterprise deployments use: one hosted server, many users, real authentication.

Authorization

A remote MCP server is an OAuth 2.1 resource server. It publishes protected resource metadata that points clients at your authorization server, accepts access tokens issued for it specifically, and rejects tokens minted for anything else. It never forwards a client’s token to upstream APIs; it calls them with its own properly scoped credentials. In practice, this means your existing identity provider stays in charge of who can do what.

We go deeper in Securing a remote MCP server.

MCP Apps

MCP Apps is an official extension that lets a server return interactive UI which the host renders inside the conversation. Some flows don’t belong in text: picking a time slot, reviewing a change before approving it, or configuring a report. For those, a small widget beats a wall of prose, and the user never leaves the assistant.

Who governs it

MCP started at Anthropic as an open specification and is now governed by the Agentic AI Foundation under the Linux Foundation, which Anthropic, OpenAI, and Block co-founded in December 2025. The major assistants all support it. For a roadmap decision, that combination matters: you’re not betting on which assistant wins, and no single vendor can change the rules on you.

What this means for your product

The protocol is the easy part. A server that technically speaks MCP can still fail its users: tools the model picks wrong, tokens that grant too much, results that blow the context budget. What decides whether agents succeed is tool design, authorization, and measurement.

Start with MCP tool design: why fewer, task-shaped tools win, or see how we build them on our services page.