Back to Blog
MCP WordPress AI Agents Developer Guide

What is MCP? A Plain English Guide for WordPress Developers

Axtolab —

If you have been building WordPress sites for any length of time, you have lived through the REST API becoming the standard way external systems talk to WordPress. You have probably built integrations with it — connecting forms to CRMs, syncing products with inventory systems, pulling content into mobile apps.

Now there is a new protocol gaining traction, and it is aimed at a different kind of external system: AI agents. The Model Context Protocol, or MCP, is an open standard that defines how AI assistants like Claude, ChatGPT, or Cursor connect to tools and services. If you want an AI agent to manage your WordPress site — create posts, update products, moderate comments — MCP is how that connection works.

Most WordPress developers have not heard of it yet. This guide explains what it is, why it exists, and what it means for you.

The Old Way: REST APIs, Custom Integrations, Endless Maintenance

WordPress developers already know how to build API integrations. The WordPress REST API is solid, well-documented, and handles most use cases. So why do we need something else?

The issue is not with the REST API itself — it is with how AI agents consume APIs. When you build a traditional integration, you write code that knows exactly which endpoints to call, what parameters to send, and how to interpret the response. That integration is specific to one API and one use case.

AI agents work differently. They need to discover what is available, understand the shape of the data, and decide at runtime which actions to take based on a conversation. A REST API gives you endpoints. An AI agent needs tools — described, typed, and structured so that a language model can reason about when and how to use them.

Before MCP, every AI-to-service integration was a one-off. Connecting Claude to WordPress required custom code. Connecting ChatGPT to WordPress required different custom code. Connecting either to Shopify was another project entirely. Each combination of AI system and external service needed its own bespoke integration, and each one broke independently when either side changed.

That is the problem MCP solves.

What MCP Actually Is: The USB-C of AI Connections

Think about what USB-C did for hardware. Before USB-C, you needed different cables for different devices — Lightning for your phone, micro-USB for your tablet, a proprietary connector for your camera. USB-C standardised the physical connection so that one cable works with everything.

MCP does the same thing for AI agent connections. It standardises how AI assistants connect to external systems, so one protocol works across all compatible tools and services.

In concrete terms, MCP defines:

  • A server that exposes capabilities (tools, resources, prompts) from an external system
  • A client built into the AI assistant that discovers and calls those capabilities
  • A transport layer that handles the communication between them

Instead of each AI vendor building custom integrations with each service, the service builds one MCP server, and every compatible AI assistant can use it. WordPress builds one MCP server; Claude, ChatGPT, Cursor, Windsurf, and any future AI assistant can all connect through it.

The result is that connecting an AI agent to a new service goes from “build a custom integration” to “add a configuration block.”

How MCP Works: Tools, Schemas, and Transport

If you are a developer who wants to understand the mechanics, here is how the pieces fit together.

Tools

An MCP server exposes tools — discrete actions that an AI agent can invoke. For a WordPress MCP server, tools might include create_post, update_product, list_comments, or get_site_info. Each tool has a name, a description (so the AI understands when to use it), and a JSON Schema defining its input parameters.

When Claude sees a tool called create_post with a description that says “Create a new WordPress post with a title, content, and status,” it can decide on its own — based on the conversation — when it makes sense to call that tool. You do not need to hard-code the workflow.

Schemas

Every tool input and output is defined using JSON Schema. This matters because it gives the AI agent structured expectations about what data to provide and what data it will get back. Instead of parsing free-text API responses, the agent works with typed, predictable data.

For example, the create_post tool might require:

{
  "title": "string (required)",
  "content": "string (required)",
  "status": "draft | publish | pending (default: draft)"
}

The AI reads this schema, knows exactly what to provide, and can validate its own inputs before making the call.

Transport

MCP currently supports two transport mechanisms: stdio (standard input/output) and SSE (Server-Sent Events over HTTP). Most local setups use stdio, where the AI assistant spawns the MCP server as a subprocess and communicates through stdin/stdout. This is simple, requires no network configuration, and works well for desktop AI tools like Claude Desktop.

For remote or server-based setups, SSE provides HTTP-based communication that works across networks.

Why MCP Matters for WordPress

Here is where it gets practical. The Axtolab WordPress MCP Server is an open-source MCP server that connects AI agents to WordPress sites. Once configured, your AI assistant can interact with your WordPress site directly — managing content, querying products, inspecting site settings — all through a standard protocol.

What You Can Do

With the WordPress MCP Server connected, an AI agent can:

  • Content management: Create, read, update, and delete posts. Change publish status. Set categories and tags.
  • WooCommerce: Query products, update prices, modify descriptions, check stock levels.
  • Site inspection: Read site title, tagline, URL, and configuration.
  • Media: Upload and manage media files.
  • Comments: List, approve, or delete comments.

The practical value is workflow integration. You are discussing your content calendar with Claude. It can check what posts you already have, create drafts for the ones you have planned, and set them to pending review — without you opening the WordPress admin.

Claude Desktop Configuration

Connecting the WordPress MCP Server to Claude Desktop takes about five minutes. Here is what the configuration looks like in your claude_desktop_config.json:

{
  "mcpServers": {
    "wordpress": {
      "command": "npx",
      "args": ["-y", "axtolab-wordpress-mcp"],
      "env": {
        "WP_PLUGIN_BASE_URL": "https://your-site.com/wp-json/wp-mcp-gateway/v1",
        "WP_USERNAME": "your-username",
        "WP_APP_PASSWORD": "xxxx xxxx xxxx xxxx"
      }
    }
  }
}

You generate an application password in your WordPress admin under Users > Your Profile > Application Passwords. Add it to the config, restart Claude Desktop, and the WordPress tools appear in your conversation.

For a detailed walkthrough, see our guide: How to Connect Claude to WordPress with MCP.

Setup in 5 Minutes

If you want to try this now, here is the short version:

  1. Generate an application password in your WordPress admin (Users > Profile > Application Passwords)
  2. Install the MCP server — no local setup required, npx handles it
  3. Add the config block above to your Claude Desktop configuration file
  4. Restart Claude Desktop — you should see WordPress tools available in your conversation
  5. Test it — ask Claude to list your recent posts or create a draft

The full step-by-step guide with screenshots and troubleshooting is at How to Connect Claude to WordPress with MCP.

Where MCP Is Heading

MCP is still relatively new, but the trajectory is clear.

Growing ecosystem. The number of MCP servers is expanding rapidly. There are servers for databases, file systems, APIs, development tools, and more. WordPress is one of the first content management systems to have a dedicated MCP server, which puts WordPress developers in a position to adopt AI workflows earlier than most.

Anthropic backing. Anthropic created the MCP specification and has built native support into Claude. This is not a side project — it is a core part of how Claude connects to the outside world. The specification is open, and other AI providers are adopting it.

Beyond desktop tools. MCP started with local desktop tools like Claude Desktop and Cursor, but the protocol is designed to work in server environments too. As AI agents move into production workflows — running autonomously, handling tasks on schedules, responding to events — MCP provides the connection layer they need.

More platforms coming. WordPress is one integration point. Shopify, Notion, Linear, and dozens of other platforms either have MCP servers already or are building them. For developers who work across multiple systems, MCP means learning one protocol instead of a dozen APIs.

For WordPress developers specifically, the takeaway is straightforward: MCP is the emerging standard for how AI interacts with your sites and tools. Understanding it now — while the ecosystem is still forming — means you can build on it before your competitors know it exists.

The Axtolab WordPress MCP Server is open source and available at github.com/Axtolab/wordpress-mcp-server. Try it, open issues, and let us know what tools you need.

Back to Blog