Best MCP Servers for WordPress Developers in 2026

WordPress development has a particular kind of complexity that other stacks do not share. You are working across PHP templates, a MySQL database full of serialized options and post meta, a hook system with thousands of filters and actions, and a plugin ecosystem where conflicts are the norm rather than the exception. Your AI coding assistant can help with all of this, but only if it has access to your actual WordPress site, your database, your theme files, and accurate documentation for the hooks you are using. MCP servers provide that access.

Without MCP servers, your assistant is guessing. It knows WordPress in general, but it does not know your site's specific configuration, your custom post types, your active plugins, or the exact version of WordPress you are running. With the right MCP servers connected, the assistant can read your theme files, query your database, check WordPress function documentation, and manage posts and pages -- all without you switching between your editor, phpMyAdmin, the WordPress admin panel, and the WordPress developer handbook.

Here are the five MCP servers that transform WordPress development.

WordPress MCP -- Site Management from Your Editor

Author: Community | Tools: 10 | Requires: WordPress URL and app password

WordPress MCP connects your AI assistant to your WordPress site through the REST API. It can create and edit posts, manage pages, handle media, and interact with your site's content -- all from your editor. This eliminates the constant back-and-forth between your code editor and the WordPress admin panel that defines most WordPress development workflows.

What It Does

Ten tools covering core WordPress content operations: creating and editing posts, managing pages, uploading and organizing media, reading site settings, and interacting with custom post types. The server communicates through the WordPress REST API using application passwords, so it has the same access as an admin user in the browser.

How It Helps in Practice

You are building a custom theme and need test content to verify your templates. Instead of manually creating posts in the admin panel -- adding featured images, setting categories, filling in custom fields -- you tell your assistant to create a set of test posts with realistic content, specific categories, and placeholder images. It creates them through the API, and your theme immediately has content to render.

Or you are migrating content between sections of your site. You need to move 50 posts from one category to another and update their slugs to match a new URL structure. Your assistant can query the posts, make the changes, and verify the results -- a task that would take significant manual clicking in the admin panel.

Configuration

{
  "mcpServers": {
    "wordpress": {
      "command": "npx",
      "args": ["-y", "wordpress-mcp"],
      "env": {
        "WORDPRESS_URL": "https://your-site.com",
        "WORDPRESS_USERNAME": "admin",
        "WORDPRESS_APP_PASSWORD": "xxxx xxxx xxxx xxxx"
      }
    }
  }
}

Generate an application password from your WordPress admin under Users > Your Profile > Application Passwords.

MySQL MCP -- Direct Database Access for the Hard Problems

Author: Community | Tools: 6 | Requires: MySQL credentials

WordPress stores everything in MySQL -- posts, options, user meta, plugin settings, transients, and the serialized data structures that make WordPress both flexible and frustrating to debug. MySQL MCP gives your assistant direct access to your WordPress database so it can run queries, inspect schemas, and debug data-level issues that the REST API cannot reach.

What It Does

Six tools for MySQL interaction: executing SELECT queries, inspecting table schemas, listing databases and tables, and running data analysis queries. Your assistant can read the wp_options table, query post meta, inspect custom tables created by plugins, and trace data relationships across the WordPress schema.

How It Helps in Practice

A plugin is misbehaving and you suspect it is storing incorrect data in the options table. Instead of opening phpMyAdmin and manually searching through rows of serialized PHP arrays, you ask your assistant to query the relevant option, unserialize the data, and explain what it contains. It reads the raw database value, parses the serialized structure, and tells you exactly what is wrong.

Or you need to audit your site's post meta usage. Which custom fields are actually being used? How many posts have each meta key? Are there orphaned meta entries from plugins you deleted months ago? Your assistant can run the analysis queries against wp_postmeta and give you a clear picture of your data landscape.

This is also invaluable for WooCommerce sites. Order data, product attributes, and customer metadata all live in custom tables and post meta. Your assistant can query order patterns, check inventory data, and debug pricing calculations directly in the database.

Configuration

{
  "mcpServers": {
    "mysql": {
      "command": "npx",
      "args": ["-y", "mysql-mcp"],
      "env": {
        "MYSQL_HOST": "localhost",
        "MYSQL_USER": "wp_user",
        "MYSQL_PASSWORD": "your-password",
        "MYSQL_DATABASE": "wordpress_db"
      }
    }
  }
}

Use your local development database credentials. Never point this at a production database without read-only access.

Filesystem MCP -- Theme and Plugin Development

Author: Anthropic | Tools: 11 | Setup: Zero-config

WordPress themes and plugins are PHP files on disk. When you are developing or debugging them, you need your assistant to read template files, understand the file structure, search for hook usage across your theme, and sometimes edit files directly. Filesystem MCP provides secure, scoped access to your WordPress project's files and directories.

What It Does

Eleven tools for file operations: reading file contents, listing directories, searching within files, creating new files, editing existing files, and managing the file system. Access is limited to directories you explicitly specify, so you can scope it to your theme directory, your plugin directory, or your entire WordPress installation.

How It Helps in Practice

You are debugging a template hierarchy issue -- a page is not using the template you expect. Your assistant reads your theme's file structure, checks the template hierarchy rules, identifies which template file WordPress would select for the given URL, and finds the problem. Maybe you named the file page-about.php but the page slug is actually about-us.

For plugin development, Filesystem MCP shines when you need to understand a third-party plugin's code. You are writing a compatibility layer and need to know exactly how another plugin registers its custom post types or modifies the main query. Your assistant reads the plugin's PHP files, traces the hook registrations, and explains the implementation details you need to know.

Searching across files is where this gets particularly useful. You need to find every place your theme or plugin uses the pre_get_posts filter. Your assistant searches all PHP files in your project directory and returns a comprehensive list, which you can then review for conflicts or optimization opportunities.

Configuration

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

Scope it to wp-content for theme and plugin development, or to the full WordPress root if you need access to core files.

GitHub MCP -- Version Control for WordPress Projects

Author: Anthropic | Tools: 20 | Requires: GitHub personal access token

Professional WordPress development uses version control. Your custom theme lives in a Git repository. Your custom plugins have their own repos. You might even have a full WordPress project managed with Bedrock or a similar structure. GitHub MCP connects your assistant to these repositories so it can track changes, review pull requests, and manage the code collaboration side of WordPress development.

What It Does

Twenty tools for GitHub: reading repository contents, managing issues and pull requests, creating and updating files, working with branches, and inspecting diffs. For WordPress developers, the most relevant capabilities are reviewing theme and plugin changes in PRs, searching issues for reported bugs, and managing releases.

How It Helps in Practice

You maintain a WordPress plugin with an active user base. Users report issues on GitHub, and you need to triage them efficiently. Your assistant reads new issues, cross-references them with your plugin's code (what version are they using, does the reported bug match the current implementation), and helps you prioritize and respond.

For team-based WordPress projects, GitHub MCP streamlines code review. A teammate submitted a PR that modifies the theme's functions.php and adds three new template files. Your assistant reads the diff, checks for common WordPress mistakes (improper escaping, missing nonces, unregistered scripts), and drafts review comments.

Configuration

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your-token"
      }
    }
  }
}

Use a token with access to your WordPress project repositories.

Context7 MCP -- WordPress Hooks and Functions, Verified

Author: Upstash | Tools: 2 | Setup: Zero-config (npx)

WordPress has thousands of hooks, filters, and functions. The developer handbook is the authoritative source, but your AI assistant's training data might reference deprecated functions, use incorrect parameter orders, or miss newly added hooks. Context7 MCP pulls live WordPress documentation into the conversation, so when your assistant writes add_action() or references the_content filter, it uses the current, correct API.

What It Does

Two tools: one resolves a library name to a Context7 ID (works with "wordpress" and individual WordPress packages), and the other queries the documentation with a specific question. It returns current documentation snippets and code examples. This covers WordPress core functions, hooks, the REST API, and the block editor (Gutenberg) APIs.

How It Helps in Practice

You are building a custom block for the block editor and need to use the @wordpress/blocks package. The Gutenberg API evolves rapidly, and your assistant might suggest patterns from two versions ago. With Context7, it pulls the current block registration API, the correct attribute definitions, and working edit and save function examples.

Or you are writing a custom query using WP_Query and cannot remember the exact meta query syntax for comparing dates. Your assistant queries the WordPress documentation, gets the correct parameters, and writes the query accurately -- including edge cases like meta_type for date comparisons that are easy to forget.

Configuration

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"]
    }
  }
}

No API key required.

Combining Everything -- The WordPress Developer Workflow

These servers cover the full WordPress development cycle:

1. Coding: Filesystem MCP reads and edits theme and plugin files. Context7 ensures correct WordPress function usage.
2. Database: MySQL MCP queries post meta, options, and custom tables for debugging and analysis.
3. Content: WordPress MCP manages posts, pages, and media for testing and content operations.
4. Collaboration: GitHub MCP handles version control, code review, and issue tracking.

A realistic workflow: you are adding a custom WooCommerce product type. Your assistant reads the WooCommerce source files via Filesystem to understand the existing product type registration (because the docs for custom product types are sparse). It checks Context7 for the correct WordPress hooks to use. It queries MySQL to understand the existing product data structure. It creates test products via WordPress MCP to verify the implementation. And it opens a PR on GitHub when the feature is ready for review.

Getting Started

Pick the servers that match your immediate needs:

• Building themes or plugins? Filesystem MCP is essential for reading and editing PHP files.
• Debugging data issues? MySQL MCP gives you direct database access.
• Managing content programmatically? WordPress MCP handles posts, pages, and media.
• Writing WordPress-specific code? Context7 MCP ensures correct hook and function usage.
• Working with a team? GitHub MCP streamlines collaboration.

For a pre-configured setup, check out the WordPress Developer Stack on stackmcp.dev. It includes the full configuration for Claude Code, Cursor, Windsurf, and other supported clients.