What Is MCP? Model Context Protocol Explained from Real Use (2026 Spec)

MCP is an open protocol that lets AI applications connect to external data and tools through a single shared standard. It stands for Model Context Protocol, created by Anthropic. Before MCP, wiring an AI app to GitHub, a database, or Google Sheets meant writing bespoke glue code every time. With MCP you write the connector once and every compatible AI app can use it. One note before you read on: this article follows the 2026-07-28 spec revision, the current one at the time of writing, and it changed some fundamentals — most explainers still describe the 2025 spec, which has been superseded.

What Does MCP Stand For, and What Are Its Parts?

MCP stands for Model Context Protocol, an open standard Anthropic released in late 2024 and made free for anyone to implement. The spec itself says it takes inspiration from the Language Server Protocol (LSP) used by VS Code — LSP let you write language support once and use it in any editor. MCP does the same thing for AI tooling. There are three parts, using the official definitions:

1. 1.Host — the LLM application that initiates connections, such as Claude Desktop, Claude Code, Cursor, or your own app
2. 2.Client — the connector living inside the host, one per server
3. 3.Server — the service that provides context and capabilities, e.g. a bridge to GitHub, a database, or an external API

What Changed in the 2026-07-28 Spec

This is the most important section here, because the latest revision changed a core assumption. Previously (2025 spec): connecting created a connection-scoped session with an initialize handshake, and servers could send requests back to clients. Now (2026-07-28): the base protocol is documented as stateless, self-contained requests with per-request capability negotiation. Every request carries what it needs, so nothing depends on a live session — and the spec states plainly that "servers do not initiate JSON-RPC requests and clients do not send JSON-RPC responses." Why it matters in practice: with requests no longer bound to a session, putting a load balancer in front of an MCP server or running one on serverless becomes ordinary instead of requiring sticky sessions. If you are taking MCP to production, this is the detail that decides your architecture.

What Capabilities Does MCP Give an AI?

The spec splits this into three things a server offers a client, plus one the client offers back:

• •Tools — functions the model can execute, e.g. create_issue(), query_database()
• •Resources — context and data for the user or the model to use
• •Prompts — templated messages and workflows for users to invoke
• •Elicitation (client side) — lets a server ask the user for more information mid-task instead of guessing or failing

Extensions Worth Knowing

Beyond the core protocol the spec defines opt-in extensions that both sides must support. The notable ones:

• •Tasks — asynchronous execution of long-running work, with polling, mid-flight input, and durable handles
• •MCP Apps — interactive UI rendered inline in the conversation: charts, forms, video players
• •Skills over MCP — structured instructions for agent workflows

How Is MCP Different From a Regular API?

The short answer: MCP does not replace APIs, it wraps them so a model can use them.

What I Actually Use MCP For

This part is not from the docs — it is from using it daily, and I think it answers the question better than theory does. The article you are reading was produced through MCP end to end. The keyword volumes and SERP data behind the decision to write it came from DataForSEO MCP. Every illustration was generated through another MCP server. When I need the current syntax of a library that shipped an update recently, Context7 MCP pulls the real docs instead of letting the model answer from memory. The concrete difference: what used to be open the DataForSEO dashboard, export a CSV, read it separately is now a plain-language request that returns numbers inside the same context where the writing is happening.

Real Costs, and the Trap Nobody Warns You About

MCP itself is free — open standard, no licence fee. The real cost comes from three places: 1. The model — the subscription or API spend for whichever AI you use (see AI cost comparison for Thai businesses) 2. The service at the far end — MCP is only the wire; if the thing it reaches charges per request, you pay that 3. Context eaten for free — this is the one I learned the hard way Every MCP server you connect injects its tool list and descriptions into the context before you type a single word. Keeping 7-8 connected but unused means paying for those tokens on every turn and leaving less room for the actual work. Practical advice: enable only what the current job needs, not everything you can find.

How to Get Started

This revision defines exactly two standard transports: stdio (newline-delimited messages over the standard streams of a client-launched subprocess) and Streamable HTTP (an HTTP POST per message to a single endpoint, answered as JSON or a request-scoped SSE stream). Running locally, stdio is the simplest and takes a few lines:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/project"]
    }
  }
}

Restart the app and ask for something that requires real files. If the answer matches what is actually on your disk, it is connected. For where MCP sits inside a full agent stack, read What is an Agent Harness; to start with Claude specifically, there is a separate Claude Code guide.