What Is MCP? The Complete Guide to the Model Context Protocol (2026)

Short answer: The Model Context Protocol (MCP) is an open standard, originally created at Anthropic by David Soria Parra and Justin Spahr-Summers and released on November 25, 2024. Anthropic donated it to the Linux Foundation’s Agentic AI Foundation on December 9, 2025. MCP lets AI applications like Claude, Cursor, VS Code, GitHub Copilot, and ChatGPT connect to external tools and data sources in a consistent way. Instead of every AI vendor inventing its own plugin format, MCP defines a shared interface — think of it as “USB-C for AI applications.” Once a tool or data source speaks MCP, any compatible AI client can use it.

This guide walks through what MCP actually is, how it works under the hood, how it differs from the WordPress REST API or services like Zapier, and how to put it to work on a WordPress site without writing any code.

What MCP Is, in One Paragraph

The Model Context Protocol is an open, JSON-RPC-based standard for connecting AI applications to external tools, data, and workflows. It defines three things: a set of primitives (Tools, Resources, Prompts) that a server can expose, a set of transports (STDIO for local, Streamable HTTP for remote) for how clients and servers talk, and a lifecycle for how connections initialize, exchange capabilities, and shut down. Anthropic released MCP in November 2024 and donated it to the Linux Foundation’s Agentic AI Foundation (AAIF) on December 9, 2025. The AAIF is co-founded by Anthropic, Block, and OpenAI, with platinum support from AWS, Bloomberg, Cloudflare, Google, and Microsoft. According to the Linux Foundation, more than 10,000 MCP servers have been published as of the donation date.

Why MCP Exists: The M × N Problem

Before MCP, every combination of AI application and external system needed its own custom integration. If you had M AI clients (Claude, ChatGPT, Cursor…) and N services (Salesforce, GitHub, WordPress…), you had M × N bespoke integrations to build and maintain. That is the fragmentation problem — and it is why early AI plugin ecosystems never scaled.

MCP collapses this to M + N. Each AI client implements the MCP protocol once. Each service exposes itself once as an MCP server. After that, any MCP-capable client can talk to any MCP-capable server. The same WordPress MCP server you connect to Claude Desktop today will work tomorrow with Cursor, with VS Code, with ChatGPT Developer Mode, with n8n — without you doing anything extra on the server side.

The community often describes MCP as “USB-C for AI applications”: one standardised port, every device. The phrase isn’t in Anthropic’s original November 2024 announcement, but it has since been widely adopted by Anthropic and the MCP maintainers.

How MCP Works: The Architecture

MCP has a three-tier architecture. Understand these three roles and the rest of the spec falls into place.

Role	What it is	Example
Host	The AI application that drives the conversation	Claude Desktop, Claude Code, Cursor, VS Code, ChatGPT
Client	A protocol connector inside the host, one per server	Created automatically by the host
Server	The program exposing tools, data, or prompts	Easy MCP AI plugin, WordPress MCP Adapter, GitHub MCP server

A host can manage many clients at once — each one paired 1:1 with a different server. So a single Claude Desktop session can simultaneously talk to a WordPress server, a GitHub server, a Postgres server, and a filesystem server. The model sees one unified set of tools and decides which one to call based on the user’s request.

Communication happens over JSON-RPC 2.0, the same lightweight RPC format used by the Language Server Protocol that powers VS Code’s language support. MCP took explicit inspiration from LSP: just as LSP standardises how editors talk to language servers, MCP standardises how AI hosts talk to context servers.

Two transports

MCP supports two official transports:

STDIO — for local subprocesses. The host launches the server as a child process and they exchange JSON-RPC messages over standard input/output. Fast, simple, ideal for local dev tools.
Streamable HTTP — for remote servers reachable over the public internet. A single HTTP endpoint handles both request/response and streaming via optional Server-Sent Events. This is the production transport for hosted services like Easy MCP AI or WordPress.com’s native MCP.

Both transports carry the same JSON-RPC messages, so a server implementation can support either without changing its business logic.

The Three Server Primitives

An MCP server exposes capabilities through three primitive types. Think of them as the verbs (Tools), the nouns (Resources), and the recipes (Prompts) of the AI–system conversation.

1. Tools (actions)

Tools are executable functions the AI can invoke. Each tool has a JSON schema describing its inputs and outputs, plus a description the model reads to decide when to use it. Tools are model-controlled — the AI decides when to call them, then asks the user (in most clients) to approve the call.

Examples on a WordPress MCP server:

wp_create_post — create a new blog post
wp_update_post_meta — set a custom field
wp_wc_list_orders — list WooCommerce orders
wp_aioseo_update_post_seo — update the SEO metadata on a post

If REST APIs are endpoints, MCP tools are typed, self-describing functions — the model can introspect them at runtime and figure out the right call without you wiring it up.

2. Resources (read-only data)

Resources are URI-addressable data sources the AI can read but not execute. They give the model context — file contents, database records, API responses, log files — without granting it permission to act. Resources are application-controlled — the host decides which resources to surface to the model.

The security distinction matters: a Resource exposes information, a Tool exposes action. A misuse of a Resource leaks data; a misuse of a Tool can change state.

3. Prompts (templated workflows)

Prompts are reusable templates that structure a multi-step interaction. They are user-controlled — invoked by the user via a slash command, autocomplete, or menu — and the host expands them into a guided conversation.

Think of Prompts as starter scripts the server author knows the user will need often: a “publish a blog post with SEO” prompt, a “audit my product inventory” prompt, a “summarise this week’s comments” prompt.

The Client-Side Primitives

Less talked about but equally important — MCP defines primitives that go the other direction, from server back to host:

Sampling — a server can ask the host’s LLM to complete a sub-task on its behalf. This is how agentic, recursive workflows are built.
Roots — a server can ask the host which filesystem paths or URIs it is allowed to operate within.
Elicitation — a server can request additional input from the user mid-call, with a structured form.

Most user-facing tutorials skip these because day-one workflows don’t need them. But they are why MCP can power complex agentic systems, not just single tool calls.

MCP vs the Alternatives

Where does MCP sit relative to the things it might replace?

	MCP	REST API	Zapier / n8n	ChatGPT Plugins (legacy)
Discovery	Runtime, typed schemas	Manual via docs	Pre-built integrations	OpenAPI manifest
AI-native	Yes — built for LLMs	No — built for humans	No — built for trigger/action flows	Yes — but tied to one vendor
Cross-vendor	Yes — any MCP client	Yes — any HTTP client	Per-platform	OpenAI-only
Stateful sessions	Yes (capability negotiation)	No	No	Limited
Streaming	Yes (SSE)	Possible but uncommon	No	Limited
Permission model	Per-tool consent at call time	Per-key, all-or-nothing	Per-integration	Per-plugin

The simplest way to think about it: REST is what humans call from code. MCP is what AI calls from a chat window. They are not competitors — Easy MCP AI, for example, uses the WordPress REST API under the hood to fulfill MCP tool calls. MCP is the layer that makes those endpoints discoverable, typed, and safe for an LLM to drive.

MCP for WordPress: The Practical Stack

In 2026, a WordPress site joins the MCP ecosystem through one of these paths:

Easy MCP AI — the most complete self-hosted MCP server for WordPress. OAuth 2.1 one-click connect, no Node.js, no proxy, full WooCommerce / Yoast / AIOSEO / ACF coverage out of the box.
WordPress MCP Adapter — the official adapter maintained under the WordPress organisation at github.com/WordPress/mcp-adapter. It pairs with the WordPress 6.9 Abilities API and uses the Automattic-maintained @automattic/mcp-wordpress-remote npx proxy for HTTP transport.
WordPress.com native — built in for WordPress.com-hosted sites. No plugin install needed.

WordPress 6.9 added the Abilities API to core — a standardised way for plugins to register what they can do (create_post, update_product, summarise_comments, etc.). The MCP Adapter exposes those abilities as MCP tools. Easy MCP AI ships its own complete toolset directly, so it works on any modern WordPress version regardless of whether you have third-party plugins that have adopted the Abilities API yet.

We covered the full setup walkthrough — including Claude Desktop, Claude Code, and Cursor — in our Claude MCP WordPress integration guide.

What You Can Actually Do With MCP + WordPress

A handful of real prompts that work on day one, once Easy MCP AI is connected:

“Draft a 1,200-word post about WordPress security in 2026, set the Yoast focus keyword to ‘wordpress security 2026,’ and save as draft.”
“List the 10 most-recent posts missing a meta description and generate one for each under 155 characters.”
“Find every WooCommerce product in the Accessories category and add ‘30-day return policy’ to the short description.”
“Show me images in the media library larger than 1 MB without alt text. Suggest alt text for the first ten.”
“List all users with the Administrator role who haven’t logged in for 90 days.”
“For every post in the Tutorials category published in 2026, audit the SEO title length and flag the ones over 60 characters.”
“Pull this month’s organic traffic from Search Console and write a 200-word recap I can paste into a Slack channel.”
“Run a DataForSEO keyword search for ‘wordpress hosting,’ pick the five with the highest volume and lowest difficulty, and outline a blog post around the top one.”

None of these require code. They are not chatbots replying with advice — the AI is executing real changes against real endpoints, with you approving each consequential action.

MCP-Capable AI Clients (2026)

The ecosystem now includes:

Client	Vendor
Claude.ai (web)	Anthropic
Claude Desktop	Anthropic
Claude Code	Anthropic
Cursor	Cursor
VS Code	Microsoft
GitHub Copilot	GitHub
Gemini CLI	Google
Amazon Q	AWS
ChatGPT (Developer Mode)	OpenAI
n8n	n8n
Windsurf	Codeium
Goose	Block

All of these clients have shipped MCP support; specific transports (STDIO vs Streamable HTTP) and feature coverage vary — check each client’s documentation for current capabilities. The same WordPress MCP server works with every client on this list. Configure once, connect anywhere.

Security: What Actually Protects You

MCP is powerful — which is shorthand for “it can do damage if you wire it carelessly.” The protocol bakes in several safety layers:

Capability negotiation at session start — the client and server explicitly declare what each side supports. No silent escalation.
Per-call user consent — by default, MCP hosts like Claude Desktop prompt the user before executing any Tool call. “Always allow” is opt-in, per tool.
Authorization framework on HTTP transport — OAuth 2.1 with PKCE, dynamic client registration (RFC 7591), refresh token rotation, audience-bound tokens (RFC 8707), and revocation (RFC 7009).
Granular scopes — well-built MCP servers (like Easy MCP AI) let you grant permission per content type and per action, not per user role.
Resources vs Tools separation — reading data and taking action are distinct primitives, so you can grant one without the other.

What MCP does not do for you:

It does not validate that an individual tool implementation is safe — that is on the server author.
It does not prevent prompt injection. A malicious resource can try to influence the model’s behavior. Treat untrusted content as untrusted.
It does not encrypt your data on the wire if you connect over plain HTTP. Always use HTTPS in production.

What Changed in 2025–2026

MCP is moving fast. The pieces worth knowing about:

December 9, 2025 — Anthropic donates MCP to the Linux Foundation’s Agentic AI Foundation. The AAIF launches with three founding projects: Anthropic’s MCP, Block’s goose, and OpenAI’s AGENTS.md. MCP becomes a vendor-neutral standard.
Spec 2025-11-25 — current stable revision. Streamable HTTP replaces the older HTTP+SSE dual-endpoint model. Authorization framework finalised.
November 24, 2025 — Anthropic announces the Tool Search Tool on the Claude Developer Platform. When tool definitions exceed ~10K tokens, tools can be marked defer_loading: true so only 3–5 relevant tools are loaded per turn. Anthropic’s published benchmarks: 85% token reduction, Opus 4 accuracy 49% → 74%, Opus 4.5 accuracy 79.5% → 88.1%.
January 26, 2026 — MCP Apps ships as the protocol’s first official extension. Tools can return interactive UI rendered in a sandboxed iframe inside the chat. Claude (web + desktop), Goose, VS Code Insiders, and ChatGPT support it at launch.
Spec 2026-07-28 (release candidate) — the largest revision since launch. Removes the initialize/initialized handshake, makes the protocol stateless at the layer level (any request can land on any server instance), adds a formal extensions framework, and introduces the Tasks extension for long-running operations.

The takeaway: MCP is not an Anthropic side project. It is governed like Kubernetes — open, neutral, and on a published release cadence.

Common Misconceptions

“MCP is just chatbot plugins under a new name.” — No. Chatbot plugins are vendor-specific surfaces. MCP is a wire-level protocol that any vendor can implement. The closer analogy is HTTP versus a vendor SDK.

“MCP requires me to write code.” — No. If your goal is to use MCP, install a server (like Easy MCP AI) and a client (like Claude Desktop). Both are point-and-click for non-developers. Writing your own MCP server is a separate project.

“MCP replaces my REST API.” — No. MCP usually sits on top of your REST API and turns it into an LLM-friendly toolset. Your REST API still exists for humans and machine clients.

“MCP is only for Claude.” — No. Cursor, VS Code, GitHub Copilot, Gemini CLI, Amazon Q, ChatGPT, n8n, Windsurf, and many others speak MCP.

“MCP means the AI can do anything on my site.” — Only what you grant it. Permission scoping is per-tool, per-resource, and consent-gated per call in most clients.

Frequently Asked Questions

Who created MCP?

Anthropic released MCP in November 2024. On December 9, 2025, Anthropic donated the protocol to the Linux Foundation’s Agentic AI Foundation (AAIF) — a directed fund co-founded by Anthropic, Block, and OpenAI, with platinum support from AWS, Bloomberg, Cloudflare, Google, and Microsoft. The protocol is now governed neutrally, the same model used for Kubernetes and the Linux kernel itself.

Is MCP free and open-source?

Yes. The specification, reference implementations, and all official SDKs are open-source. Per modelcontextprotocol.io, Tier 1 SDKs are TypeScript, Python, C#, and Go; Tier 2 are Java and Rust; Tier 3 are Swift, Ruby, and PHP; Kotlin is also maintained. There is no fee to implement an MCP server or client. You pay only for the AI client subscription (Claude Pro, etc.) and your own hosting.

What does MCP stand for?

Model Context Protocol. “Model” as in AI/LLM. “Context” as in the data and tools that surround a conversation. “Protocol” as in the wire-level specification.

Is MCP safe to enable on my WordPress site?

It can be — the controls are there. Use HTTPS, scope permissions tightly (Easy MCP AI lets you pick read/write categories per token or OAuth client), and require user approval for destructive operations. Treat connected AI clients with the same caution as any third-party app that touches your admin.

How is MCP different from a REST API?

REST APIs are designed for humans writing code. MCP is designed for LLMs discovering tools at runtime. MCP servers usually use REST APIs internally — they just add a discovery, schema, and consent layer on top so an AI can drive them safely.

Does MCP work with ChatGPT?

Yes, in OpenAI’s Developer Mode and via the Connectors framework. Scope varies by plan. Most production MCP servers (including Easy MCP AI) support both Claude and ChatGPT in parallel.

What’s the difference between MCP and Zapier?

Zapier is a no-code workflow tool with pre-built triggers and actions. MCP is a protocol for AI clients to discover and call tools at runtime. Zapier flows are deterministic (if X, do Y). MCP tool calls are AI-driven (the model decides when and how to call). The two complement each other — you can even expose Zapier as an MCP server.

Can I build my own MCP server?

Yes. Official SDKs exist for TypeScript, Python, C#, Go, Java, Rust, Swift, Ruby, PHP, and Kotlin. A minimal server is a few dozen lines of code. The MCP Inspector (npx @modelcontextprotocol/inspector) lets you test it locally.

Does MCP need WordPress 6.9?

Only if you want third-party plugins to register their own abilities via the WordPress Abilities API. Easy MCP AI ships its own complete toolset and works on older WordPress versions.

Will MCP be obsolete in a year?

Unlikely. It is now governed by the Linux Foundation, backed by Anthropic, OpenAI, Microsoft, Google, AWS, and Block. The 2026-07-28 release candidate already shows a multi-year roadmap (stateless transport, MCP Apps, Tasks extension). Bet on it the way you’d bet on HTTP.

Glossary

Host — the AI application (Claude Desktop, Cursor, etc.)
Client — the per-server protocol connector inside the host
Server — the program exposing tools, resources, prompts
Tool — executable function the AI can call (with user consent)
Resource — read-only data source the AI can access
Prompt — templated workflow invoked by the user
STDIO — local transport via stdin/stdout
Streamable HTTP — remote transport over HTTP, with optional SSE streaming
JSON-RPC 2.0 — the message format MCP uses on the wire
Abilities API — the WordPress 6.9 core API that lets plugins register typed capabilities, which the MCP Adapter then exposes as MCP tools
OAuth 2.1 / PKCE — modern auth framework MCP servers can use to grant scoped access without sharing passwords
MCP Apps — the first official MCP extension, launched January 26, 2026, that lets tools return rendered UI fragments inside the conversation
Tool Search — feature announced by Anthropic on November 24, 2025 that defers loading tool definitions until the model asks for them, cutting token overhead ~85%

Getting Started

The fastest path from zero to Claude is editing my WordPress site in under five minutes:

Install the Easy MCP AI plugin from the WordPress.org directory.
Activate it and copy your MCP server URL from the plugin dashboard.
In Claude Desktop, open Settings → Connectors → Add custom connector. Paste the URL.
Sign in to your WordPress site on the consent screen, approve the permission scopes you want, and click Connect.
Start a fresh Claude conversation and ask: “List my 5 most recent WordPress posts.”

That is the entire setup. For the full walkthrough including Claude Code, the official Automattic MCP Adapter, and WordPress.com, read our Claude MCP WordPress integration guide.

MCP is the most important AI protocol shift since OpenAI shipped function calling. Two years from now, every serious AI workflow will run through it. The question is not whether to adopt — it’s how soon.

References & Official Sources

This article was written by referencing the following primary sources. None of the prose is copied verbatim — all claims were synthesised and rewritten, but the underlying facts trace to these documents.

Original launch

Anthropic — Introducing the Model Context Protocol (anthropic.com, Nov 25 2024) — original announcement, names David Soria Parra and Justin Spahr-Summers as creators
TechCrunch — Anthropic proposes a new way to connect data to AI chatbots (techcrunch.com, Nov 25 2024)

Specification & governance

Model Context Protocol — Official specification (modelcontextprotocol.io)
MCP Architecture Overview (modelcontextprotocol.io)
MCP Official SDK list and tiers (modelcontextprotocol.io)
MCP 2026-07-28 Release Candidate announcement (blog.modelcontextprotocol.io, May 21 2026)

Tool Search Tool (Nov 24 2025)

Anthropic Engineering — Introducing advanced tool use (anthropic.com, Nov 24 2025) — primary source for the 85% token reduction, 49→74% / 79.5→88.1% accuracy benchmarks

MCP Apps (Jan 26 2026)

MCP Apps — Bringing UI Capabilities to MCP Clients (blog.modelcontextprotocol.io, Jan 26 2026)
VS Code — Giving Agents a Visual Voice: MCP Apps Support (code.visualstudio.com, Jan 26 2026)

Linux Foundation donation (December 9, 2025)

Anthropic — Donating the Model Context Protocol and establishing the Agentic AI Foundation (anthropic.com)
Linux Foundation — Announcement of the Agentic AI Foundation (AAIF) (linuxfoundation.org)
OpenAI — co-founds the Agentic AI Foundation (openai.com)
TechCrunch — OpenAI, Anthropic, and Block join new Linux Foundation effort (techcrunch.com, Dec 9 2025)

WordPress integration

WordPress/mcp-adapter on GitHub — the official WordPress MCP Adapter
Automattic/mcp-wordpress-remote on GitHub — the npx proxy
Introducing the WordPress MCP Adapter (WordPress Developer Blog, Feb 4 2026)

Reference learning material