From Abilities to AI Agents: Introducing the WordPress MCP Adapter

This will open a file browser to the location of the claude_desktop_config.json file, where you can add your MCP server configurations.

MCP Servers are added to this file in a mcpServers object.

{
  "mcpServers": {
  }
}

Here’s what the configuration looks like for connecting via STDIO transport:

{
  "mcpServers": {
    "wordpress-mcp-server": {
      "command": "wp",
      "args": [
        "--path=/Users/jonathanbossenger/Studio/wordpress-mcp",
        "mcp-adapter",
        "serve",
        "--server=mcp-adapter-default-server",
        "--user=admin"
      ]
    }
  }
}

Here’s what the configuration looks like for connecting via HTTP transport:

{
  "mcpServers": {
    "wordpress-mcp-server": {
      "command": "npx",
      "args": ["-y", "@automattic/mcp-wordpress-remote@latest"],
      "env": {
        "WP_API_URL": "http://localhost:8885/wp-json/mcp/mcp-adapter-default-server",
        "WP_API_USERNAME": "admin",
        "WP_API_PASSWORD": "2SEB qW5j D7CW fpsh pbmN RGva"
      }
    }
  }
}

Once you save the configuration file, you will have to restart Claude Desktop, as it only reads the MCP server configurations on startup.

You should now see your MCP server listed in the Developer tab under Local MCP servers. If you see the running status next to your server name, you’re ready to start using it in your conversations.

Cursor

In Cursor, navigate to the Settings tab (Cursor → Settings → Cursor Settings), then select the Tools and MCP section.

Click on Add Custom MCP button, which will open the mcp.json configuration file for Cursor.

The configuration for Cursor is the same as for Claude Desktop. Once you’ve added your MCP server configuration, save the file and navigate back to the Tools and MCP section in Cursor settings. You should see your MCP server listed there, and you can enable it for use in your coding sessions.

Claude Code

To add MCP servers to Claude Code, you can either add the mcpServers object with the relevant server configs to the .claude.json file in your home directory, or create a .mcp.json file in your project directory. Adding the MCP servers to the project directory allows you to have different MCP server configurations for different projects, whereas adding them to the home directory makes them available globally across all projects.

Either way, you can use the same configuration format as Cursor or Claude Desktop.

VS Code

Configuring VS Code to connect to an MCP server requires setting up a JSON configuration file that describes the MCP server details. This file is usually named mcp.json and should be placed in a .vscode directory inside your project workspace.

The only difference between configuring VS Code and Claude Desktop is that you define your MCP servers in a servers object not an mcpServers object. The rest of the configuration is the same.

{
  "servers": {
    // MCP server definitions go here
  }
}

Once you create this file in your project workspace, VS Code displays an MCP control toolbar, where you can start, stop and restart the MCP server.

When the server has started correctly, it will also show you how many tools are available for the AI to use, in this case, three.

Using MCP tools

With your MCP server connected to your AI application of choice, you can now start using the MCP tools exposed by the MCP Adapter.

For example, in Claude Desktop, you can start a new conversation asking Claude to “Get the site info from my WordPress site”.

It will determine that there is an available MCP server and call the mcp-adapter-discover-abilities tool to see what abilities are available. It will then determine that the core/get-site-info Ability will fulfill the request, and call the mcp-adapter-execute-ability tool, passing it the core/get-site-info Ability name. This will return the site info data, and the application will “answer” with the site information.

Configuring custom MCP Servers for your plugins

While the MCP Adapter default server should cover most requirements, you may want to create a custom MCP server for your plugin. This allows you to have more control over how your abilities are exposed as MCP tools.

Implementing this requires installing the MCP Adapter package via Composer, and creating and registering a custom MCP server.

From your plugin directory, run the composer require command:

composer require wordpress/mcp-adapter

Then, make sure to load Composer’s autoloader in your main plugin file:

if ( file_exists( __DIR__ . '/vendor/autoload.php' ) ) {
    require_once __DIR__ . '/vendor/autoload.php';
}

If it’s possible that multiple plugins on a site might depend on the MCP Adapter or Abilities API, the official documentation recommends using the Jetpack Autoloader to avoid version conflicts.

The next step is to initialize the MCP Adapter in your plugin:

if ( ! class_exists( WP\MCP\Core\McpAdapter::class ) ) {
    // check if the MCP Adapter class is available, if not show some sort of error or admin notice
    return;
}

// Initialize MCP Adapter and its default server.
WP\MCP\Core\McpAdapter::instance();

Finally, you can create a custom MCP server by hooking into the mcp_adapter_init action. The action callback function receives the McpAdapter instance. The adapter’s create_server() method is used to define the custom server, with the desired configuration.

add_action( 'mcp_adapter_init', 'myplugin_create_custom_mcp_server' );
function myplugin_create_custom_mcp_server( $adapter ) {
    $adapter = WP\MCP\Core\McpAdapter::instance();
    $adapter->create_server(
        'custom-mcp-server', // Unique server identifier.
        'custom-mcp-server', // REST API namespace.
        'mcp',               // REST API route.
        'Custom MCP Server', // Server name.
        'Custom MCP Server', // Server description.
        'v1.0.0',            // Server version.
        array(               // Transport methods.
            \WP\MCP\Transport\HttpTransport::class,  // Recommended: MCP 2025-06-18 compliant.
        ),
        \WP\MCP\Infrastructure\ErrorHandling\ErrorLogMcpErrorHandler::class, // Error handler.
        \WP\MCP\Infrastructure\Observability\NullMcpObservabilityHandler::class, // Observability handler.
        array( 'namespace/ability-name' ), // Abilities to expose as tools
        array(),                           // Resources (optional).
        array(),                           // Prompts (optional).
    );
}

The important parameters to note here are:

• The first parameter is the unique server identifier. This is used when starting the MCP server via WP-CLI.
• The second and third parameters define the REST API namespace and route for the MCP server.
• The fourth and fifth parameters are the server name and description, which are displayed in AI applications when listing available MCP servers.
• The sixth parameter is the server version.
• The tenth parameter is an array of ability names that you want to expose as MCP tools. You can list multiple abilities here.
• The rest of the parameters define the transport methods, error handling, and observability handlers. In this example, you’re using the HTTP transport, error logging, and observability handlers from the core MCP Adapter package. However, it is possible to create your own custom handlers if you want to integrate with your own transport, logging or monitoring systems.

Adding an MCP server to List All URLs

To show you an example of creating a custom MCP server, let’s take the List All URLs plugin from the Abilities API post, and add a custom MCP server to it.

Before you do this, deactivate the MCP Adapter plugin if you have it activated.

Next, clone the List All URLs GitHub repository inside your WordPress plugins directory:

cd wp-content/plugins
git clone git@github.com:wptrainingteam/list-all-urls.git

You’ll also need to switch to the branch that includes the Abilities API implementation:

cd list-all-urls
git checkout abilities

The plugin already uses Composer for dependency management, so run composer install to install the required packages.

composer install

Next require the mcp-adapter package:

composer require wordpress/mcp-adapter

Now, open the main plugin file list-all-urls.php, and add the following code at the bottom of the file to initialize the MCP Adapter and create a custom MCP server:

if ( ! class_exists( WP\MCP\Core\McpAdapter::class ) ) {
    return;
}

// Initialize MCP Adapter and its default server.
WP\MCP\Core\McpAdapter::instance();

add_action( 'mcp_adapter_init', 'list_all_urls_create_custom_mcp_server' );
/**
 * Create a custom MCP server for the List All URLs plugin.
 *
 * @param object $adapter WP\MCP\Core\McpAdapter The MCP Adapter instance.
 * @return void
 */
function list_all_urls_create_custom_mcp_server( $adapter ) {
    $adapter = WP\MCP\Core\McpAdapter::instance();
    $adapter->create_server(
        'list-all-urls-mcp-server',
        'list-all-urls-mcp-server',
        'mcp',
        'List All URLS MCP Server',
        'Custom MCP Server for the List All URLs plugin. Currently exposes only the list-all-urls/urls ability as an MCP Tool.',
        'v1.0.0',
        array(
            \WP\MCP\Transport\HttpTransport::class,
        ),
        \WP\MCP\Infrastructure\ErrorHandling\ErrorLogMcpErrorHandler::class,
        \WP\MCP\Infrastructure\Observability\NullMcpObservabilityHandler::class,
        array( 'list-all-urls/urls' ),
    );
}

Notice that you don’t need to enable the meta.mcp.public flag for the list-all-urls/urls ability, because you’re explicitly exposing it via the custom MCP server.

Now activate the List All URLs plugin from the WordPress admin dashboard.

Once the plugin is activated, update your AI application’s MCP server configuration to use the new custom MCP server.

Here’s an example of the updated VS Code configuration to include both the default MCP server and the new custom MCP server from the List All URLs plugin, both using STDIO transport:

{
  "servers": {
    "wordpress-mcp-server": {
      "command": "wp",
      "args": [
        "--path=/Users/jonathanbossenger/Studio/wordpress-mcp",
        "mcp-adapter",
        "serve",
        "--server=mcp-adapter-default-server",
        "--user=admin"
      ]
    },
    "list-all-urls-mcp-server": {
      "command": "wp",
      "args": [
        "--path=/Users/jonathanbossenger/Studio/wordpress-mcp",
        "mcp-adapter",
        "serve",
        "--server=list-all-urls-mcp-server",
        "--user=admin"
      ]
    }
  }
}

It’s possible to have multiple MCP servers configured in the same AI application. This allows you to switch between different WordPress sites or plugins that expose different sets of abilities.

Whatever AI application you’re using, make sure to either restart the application, or start the MCP server in the application after updating the MCP server configuration. You should see the new MCP server listed and be able to use the list-all-urls/urls ability as an MCP tool. You can then ask the AI to “List all URLs on my WordPress site”, and it will call the list-all-urls-urls tool via the MCP Adapter.

Security and best practices

Because MCP clients act as logged-in WordPress users, always treat them as part of your application surface area by following these best practices:

• Use permission_callback carefully
• Each ability should check the minimum capability needed (manage_options, edit_posts, etc.).
• Avoid __return_true for destructive operations such as deleting content.
• Use dedicated users for MCP access
• Especially in production, create a specific role/user with limited capabilities.
• Do not expose powerful abilities to unaudited AI clients.
• Prefer read-only abilities for public MCP endpoints
• For HTTP transports exposed over the internet, focus on read-only diagnostics, reporting, and content access.
• Implement custom authentication if needed
• The default authentication uses application passwords, but you can implement OAuth or other methods for better security.
• Monitor and log usage
• Use custom error and observability handlers to integrate with your logging/monitoring stack.

How to start experimenting today

If you want to get started experimenting with the MCP adapter, a minimal “hello AI” path for a WordPress developer only requires you to register an ability, require and initialize the MCP Adapter, and connect an MCP-aware AI client.

If you already have plugins using the Abilities API, the MCP Adapter turns them into AI-ready APIs with very little additional work.

As with any new technology, start small. Begin by exposing a few non-destructive, read-only abilities as MCP tools. Test them with local AI clients like Claude Desktop or Cursor. Gradually expand to more complex abilities and workflows as you gain confidence. Be prepared to hit roadblocks, and engage with the WordPress AI and developer communities for support and collaboration. The documentation for both the Abilities API and the MCP Adapter are great resources to help you along the way.

This combination of Abilities and the MCP Adapter gives WordPress developers a powerful path to build AI-assisted admin tools, automation, and workflows for both clients and teams.

Props to @greenshady and @bph for reviewing this post.