WordPress MCP Server: The Complete Setup Guide (MCP Adapter, Claude & AI Agents)

The official WordPress MCP Adapter turns approved WordPress abilities into tools, resources and prompts that compatible AI agents can discover and invoke. This guide shows how to install the adapter, expose abilities safely, connect Claude Desktop or Claude Code, and build useful read, draft-proposal and WooCommerce workflows without giving an AI unrestricted administrator access.[^1][^2]

> Looking for the broader WordPress AI architecture? Read Claude, Gemini and OpenAI in WordPress: AI Connectors, AI Client and MCP Explained. That guide explains AI Client, provider connectors, the canonical AI plugin, Abilities API and MCP. This article focuses specifically on deploying a WordPress MCP server.

What is WordPress MCP?

Model Context Protocol, or MCP, is a standard through which AI clients can discover structured tools, resources and prompts exposed by external systems. In WordPress, the official MCP Adapter bridges the Abilities API to MCP: a WordPress ability can become something an authorized agent can inspect and execute.[^3][^2]

The direction matters:

• AI Client + provider connector: WordPress calls an AI model.
• MCP Adapter: an external AI client calls approved WordPress abilities.

The MCP Adapter does not include Claude, ChatGPT or another model. It also does not automatically give an agent access to posts, settings or WooCommerce. It provides the server and transport layer through which explicitly exposed abilities can be used.[^4]

Prerequisites

The official minimum requirements are WordPress 6.9 and PHP 7.4 because the Abilities API entered WordPress Core in 6.9. For a new deployment, WordPress 7.1 or later is recommended because 7.1 expanded ability discovery, validation and public-exposure support.[^5]

Prepare the following:

• WordPress 7.1+ with HTTPS
• PHP 7.4+; use a currently supported PHP branch where possible
• Administrator access for installation
• A dedicated WordPress account for the MCP client
• WordPress Application Passwords for remote HTTP authentication
• WP-CLI for local STDIO setups and diagnostics
• Node.js and npx when using the official HTTP-to-STDIO proxy configuration
• A staging environment for the first deployment
• A compatible MCP client such as Claude Desktop or Claude Code

Create a dedicated user

Do not connect an everyday administrator account unless the intended abilities genuinely require administrator capabilities. Create a dedicated account such as mcp-reader, mcp-editor or mcp-commerce-reviewer, assign the narrowest suitable role, and create a separate Application Password under that user's profile.

Application Passwords are the standard WordPress mechanism recommended for external REST access. They can be revoked independently without changing the user's normal password.[^6]

Define the access model first

Before installation, decide what the agent should be allowed to do:

This design determines the WordPress role, permission callbacks and abilities that should be exposed.

Install the MCP Adapter

The MCP Adapter became available in the WordPress Plugin Directory as a canonical plugin in October 2026. It remains experimental while the project works toward a stable 1.0 release.

From WordPress administration

1. Open Plugins → Add New Plugin. 2. Search for MCP Adapter by WordPress.org. 3. Install and activate the plugin. 4. Confirm that WordPress permalinks and the REST API are working.

The adapter deliberately has no full agent-management interface. Activating it registers its server infrastructure and default MCP endpoint; abilities and client credentials are managed through WordPress code, users and the external MCP client.[^7][^4]

With WP-CLI

wp plugin install mcp-adapter --activate

If the directory package is temporarily unavailable or a specific development release is required, the project documentation also provides a GitHub release installation command. Production sites should prefer a pinned, tested release rather than an arbitrary development branch.[^8]

Confirm the plugin

wp plugin status mcp-adapter

The default server ID is:

mcp-adapter-default-server

Its remote endpoint is:

https://example.com/wp-json/mcp/mcp-adapter-default-server

The default server uses MCP Streamable HTTP and requires an authenticated WordPress user with at least the read capability unless the server permissions are customized.[^9]

Test REST availability

First check the general REST index:

curl -i https://example.com/wp-json/

A browser GET request to the MCP endpoint may not produce a useful success page because MCP communication uses authenticated JSON-RPC requests and an initialization handshake. Test it with a proper MCP client or authenticated request rather than assuming that an empty browser response means the plugin is broken.[^9]

Test through WP-CLI

WP-CLI uses the adapter's STDIO transport and is the simplest local diagnostic:

echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | \
wp mcp-adapter serve \
  --server=mcp-adapter-default-server \
  --user=mcp-reader

The command runs permission checks as the selected WordPress user. Replace mcp-reader with the dedicated username or user ID.[^10]

How the default server works

The default server does not convert every WordPress function into a separate agent tool. It exposes three meta-tools that discover and execute abilities marked for public MCP exposure:[^11][^9]

1. mcp-adapter-discover-abilities 2. mcp-adapter-get-ability-info 3. mcp-adapter-execute-ability

This architecture keeps the initial tool list small. The agent first discovers eligible abilities, retrieves the schema of the one it needs, and then requests execution.

A custom MCP server can instead expose selected abilities as direct standalone tools, resources or prompts. Custom servers are useful when a production integration needs a tightly controlled surface, clearer tool schemas or separate permission policies.[^2][^12]

Expose abilities safely

WordPress abilities are private by default. On the official MCP Adapter, use meta.public => true or the more specific meta.mcp.public => true to make an ability discoverable through the default MCP server. An explicit meta.mcp.public => false excludes an otherwise public ability from MCP.[^2][^9]

This is distinct from REST exposure. show_in_rest => true controls the Abilities REST API, whereas MCP exposure follows the public MCP metadata. Do not expose an ability to REST merely because it must be available over MCP unless the integration requires both channels.[^13][^6]

A safe read-only ability

Create a small custom plugin rather than adding integration code to a theme. Themes change with presentation; agent capabilities are application functionality.

<?php
/**
 * Plugin Name: Busony MCP Abilities
 * Description: Narrow WordPress abilities for approved MCP agents.
 * Version: 1.0.0
 */

add_action( 'wp_abilities_api_init', function () {
    wp_register_ability(
        'busony/get-published-post',
        array(
            'label'       => 'Get a published post',
            'description' => 'Returns a published post by numeric ID.',
            'category'    => 'content',
            'input_schema' => array(
                'type'                 => 'object',
                'additionalProperties' => false,
                'required'             => array( 'post_id' ),
                'properties'           => array(
                    'post_id' => array(
                        'type'    => 'integer',
                        'minimum' => 1,
                    ),
                ),
            ),
            'output_schema' => array(
                'type' => 'object',
                'properties' => array(
                    'id'      => array( 'type' => 'integer' ),
                    'title'   => array( 'type' => 'string' ),
                    'content' => array( 'type' => 'string' ),
                    'url'     => array( 'type' => 'string' ),
                ),
            ),
            'execute_callback' => function ( $input ) {
                $post = get_post( (int) $input['post_id'] );

                if ( ! $post || 'post' !== $post->post_type || 'publish' !== $post->post_status ) {
                    return new WP_Error( 'post_not_available', 'Published post not found.' );
                }

                return array(
                    'id'      => (int) $post->ID,
                    'title'   => get_the_title( $post ),
                    'content' => apply_filters( 'the_content', $post->post_content ),
                    'url'     => get_permalink( $post ),
                );
            },
            'permission_callback' => function ( $input ) {
                return current_user_can( 'read' )
                    && current_user_can( 'read_post', (int) $input['post_id'] );
            },
            'meta' => array(
                'public' => true,
                'mcp'    => array( 'public' => true ),
                'annotations' => array(
                    'readonly'    => true,
                    'destructive' => false,
                    'idempotent'  => true,
                ),
            ),
        )
    );
} );

Abilities must be registered on wp_abilities_api_init. WordPress validates the input schema before calling the permission callback, and the permission callback must return true, false or WP_Error.[^14][^15]

A draft-proposal ability

A safer editorial write pattern creates drafts rather than publishing content:

add_action( 'wp_abilities_api_init', function () {
    wp_register_ability(
        'busony/create-post-draft',
        array(
            'label'       => 'Create a post draft',
            'description' => 'Creates a reviewable post draft. It never publishes.',
            'category'    => 'content',
            'input_schema' => array(
                'type'                 => 'object',
                'additionalProperties' => false,
                'required'             => array( 'title', 'content' ),
                'properties'           => array(
                    'title' => array(
                        'type'      => 'string',
                        'minLength' => 1,
                        'maxLength' => 200,
                    ),
                    'content' => array(
                        'type'      => 'string',
                        'minLength' => 1,
                        'maxLength' => 50000,
                    ),
                ),
            ),
            'output_schema' => array(
                'type' => 'object',
                'properties' => array(
                    'post_id' => array( 'type' => 'integer' ),
                    'status'  => array( 'type' => 'string' ),
                    'edit_url'=> array( 'type' => 'string' ),
                ),
            ),
            'execute_callback' => function ( $input ) {
                $post_id = wp_insert_post(
                    array(
                        'post_type'    => 'post',
                        'post_status'  => 'draft',
                        'post_title'   => sanitize_text_field( $input['title'] ),
                        'post_content' => wp_kses_post( $input['content'] ),
                    ),
                    true
                );

                if ( is_wp_error( $post_id ) ) {
                    return $post_id;
                }

                return array(
                    'post_id' => (int) $post_id,
                    'status'  => 'draft',
                    'edit_url'=> get_edit_post_link( $post_id, 'raw' ),
                );
            },
            'permission_callback' => function () {
                return current_user_can( 'edit_posts' );
            },
            'meta' => array(
                'mcp' => array( 'public' => true ),
                'annotations' => array(
                    'readonly'    => false,
                    'destructive' => false,
                    'idempotent'  => false,
                ),
            ),
        )
    );
} );

This does not expose a publication tool. A human editor reviews and publishes through WordPress. In a mature workflow, add an idempotency key to prevent duplicate drafts when a client retries a request.

Permission rules

A secure ability should satisfy all of these conditions:

• The description is narrow and unambiguous.
• Input and output use strict JSON Schema.
• additionalProperties is disabled unless genuinely required.
• Numeric ranges and text lengths are bounded.
• The permission callback checks the current user and, where relevant, the target object.
• The execution callback sanitizes inputs and escapes or filters outputs appropriately.
• Read, write and destructive operations are separate abilities.
• Consequential actions require human confirmation or a higher-privilege account.
• The ability returns WP_Error on failure instead of leaking stack traces or secrets.

Never expose arbitrary SQL, shell commands, unrestricted PHP execution, plugin installation, user creation or direct option modification as a general agent tool.

Authenticate remote clients

The default HTTP server requires an authenticated WordPress user. For a standard remote setup, create an Application Password:

1. Sign in as the dedicated MCP user. 2. Open Users → Profile. 3. Find Application Passwords. 4. Enter a label such as Claude MCP — October 2026. 5. Generate and immediately copy the password. 6. Store it in the operating system's secure credential store or another secret manager.

The label is not the username. MCP configuration must use the actual WordPress login username plus the generated Application Password.[^7]

Test authentication with cURL

curl -i \
  --user 'mcp-reader:xxxx xxxx xxxx xxxx xxxx xxxx' \
  -H 'Content-Type: application/json' \
  -X POST \
  'https://example.com/wp-json/mcp/mcp-adapter-default-server' \
  --data '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
      "protocolVersion": "2026-07-28",
      "capabilities": {},
      "clientInfo": {
        "name": "manual-test",
        "version": "1.0.0"
      }
    }
  }'

MCP Streamable HTTP clients must complete an initialization handshake before ordinary requests. In normal use, Claude or the proxy handles this protocol exchange automatically.[^9]

Do not put an Application Password into frontend JavaScript, a public repository, an article screenshot or a shared shell history.

Connect Claude Desktop

There are two main approaches: direct local STDIO via WP-CLI, or remote HTTP through a local proxy. Choose one; do not combine settings from the former Automattic wordpress-mcp plugin, which used a different endpoint and JWT model.[^16]

Option A: local WordPress via WP-CLI

Use this when Claude Desktop runs on the same machine as the WordPress installation and can execute WP-CLI directly.

Open Claude Desktop's configuration file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Add:

{
  "mcpServers": {
    "wordpress-local": {
      "command": "wp",
      "args": [
        "--path=/absolute/path/to/wordpress",
        "mcp-adapter",
        "serve",
        "--server=mcp-adapter-default-server",
        "--user=mcp-reader"
      ]
    }
  }
}

Use the absolute WordPress path and an existing dedicated username. Depending on the operating system and how Claude Desktop launches subprocesses, the full path to the WP-CLI executable may be required instead of wp.[^10]

This STDIO method does not require HTTP session handling or an Application Password because WP-CLI runs locally as the selected WordPress user. It does require Claude Desktop to have local process and filesystem access to the installation.[^9]

Option B: remote WordPress via HTTP proxy

For a remote site, the project documentation provides the @automattic/mcp-wordpress-remote proxy. It runs locally under Claude Desktop, communicates with Claude over STDIO and translates requests to authenticated HTTP calls to WordPress.[^10]

{
  "mcpServers": {
    "wordpress-production": {
      "command": "npx",
      "args": [
        "-y",
        "@automattic/mcp-wordpress-remote@latest"
      ],
      "env": {
        "WP_API_URL": "https://example.com/wp-json/mcp/mcp-adapter-default-server",
        "WP_API_USERNAME": "mcp-reader",
        "WP_API_PASSWORD": "xxxx xxxx xxxx xxxx xxxx xxxx",
        "LOG_FILE": "/absolute/path/to/logs/wordpress-mcp.log"
      }
    }
  }
}

During initial testing, the latest tag is convenient. For a controlled production workflow, pin a tested proxy version so that an upstream release cannot unexpectedly alter behavior.

Fully quit and reopen Claude Desktop after saving the file. A page refresh is insufficient because the application must launch the MCP subprocess again.[^7]

In a new conversation, open the connectors/tools control and confirm that the WordPress server is available. Start with a read-only request such as:

> Discover the public WordPress abilities available to you. Do not execute any write action.

Then test a specific ability:

> Retrieve published post 123 using the approved WordPress ability and summarize it. Do not modify WordPress.

Direct remote connector

Current Claude clients also support custom remote MCP connectors. In Claude, open Customize → Connectors, choose Add custom connector, enter the remote MCP URL, and configure the authentication method detected by Claude.[^17]

However, Claude's remote connectors originate from Anthropic's cloud infrastructure, not from the user's local computer. The WordPress endpoint must therefore be publicly reachable from the required network ranges, and its authentication method must be compatible with Claude's connector flow.[^17]

For many self-hosted WordPress deployments, the documented local proxy plus an Application Password is the more predictable starting point. Do not configure "No sign in" on a WordPress MCP server that exposes non-public site data or executable abilities.

Connect Claude Code

Claude Code can register a local STDIO command or an HTTP MCP server. The same principle applies: use direct WP-CLI for a local WordPress installation, or launch the WordPress remote proxy for a remote site.

Local STDIO

A representative project-level MCP configuration is:

{
  "mcpServers": {
    "wordpress-local": {
      "command": "wp",
      "args": [
        "--path=/absolute/path/to/wordpress",
        "mcp-adapter",
        "serve",
        "--server=mcp-adapter-default-server",
        "--user=mcp-reader"
      ]
    }
  }
}

Remote proxy

{
  "mcpServers": {
    "wordpress-remote": {
      "command": "npx",
      "args": ["-y", "@automattic/mcp-wordpress-remote@latest"],
      "env": {
        "WP_API_URL": "https://example.com/wp-json/mcp/mcp-adapter-default-server",
        "WP_API_USERNAME": "mcp-reader",
        "WP_API_PASSWORD": "YOUR_APPLICATION_PASSWORD"
      }
    }
  }
}

The exact configuration location and command syntax can change between Claude Code releases. Check the current Claude Code MCP documentation before deployment, but preserve the WordPress-specific endpoint, username and Application Password model shown in the official adapter documentation.[^10]

Store project configuration without secrets whenever possible. Supply the Application Password from an environment variable or secret manager rather than committing it to a repository.

Practical use cases

Read-only content agent

A research agent can discover approved read abilities, retrieve published content and compare site coverage without receiving access to unpublished drafts or settings.

Recommended permissions:

• Dedicated Subscriber or custom read-only role
• Only published-content abilities
• No user enumeration
• No plugin, theme or settings abilities
• No write tools

Typical prompt:

> Review the published articles available through the WordPress MCP tools. Identify outdated statements, but do not change the site. Return proposed corrections with the relevant post IDs.

Draft-proposal agent

An editorial agent can retrieve approved source material and create a draft for human review. The ability should hard-code post_status => draft; the agent should not be able to override the status in its arguments.

Recommended permissions:

• Dedicated Contributor or custom role
• Read approved content
• Create drafts
• No publication, deletion or user-management ability
• Idempotency key and duplicate detection
• Editorial review before publication

Typical prompt:

> Read post 123 and create a separate update proposal as a draft. Preserve the original article. Include a change log at the top for the editor.

WooCommerce stock reader

The MCP Adapter does not automatically expose WooCommerce. A plugin or custom integration must register narrowly scoped WooCommerce abilities.

A read-only stock ability could accept an exact product ID or SKU and return only:

• Product ID and SKU
• Product name
• Stock status
• Managed-stock flag
• Current quantity, where the authenticated user may view it
• Last-modified time

Do not start with fuzzy product selection followed by autonomous updates. Require an exact product identifier and separate reading from writing.

Illustrative permission callback:

'permission_callback' => function () {
    return current_user_can( 'manage_woocommerce' )
        || current_user_can( 'view_woocommerce_reports' );
},

Choose capabilities according to the site's role model and the sensitivity of inventory data. Never return order customer details, payment information or unrelated store configuration from a stock-reading ability.

WooCommerce update proposal

A safer commercial workflow is:

1. Agent reads the product through a read ability. 2. Agent creates a structured proposal containing old and proposed values. 3. Human approves the proposal. 4. A separate service or privileged ability performs the update. 5. The integration reads the product again and verifies the stored result.

Direct stock, price and publication updates need stronger permissions, audit logs, idempotency protection and rollback procedures than draft content creation.

Security checklist

Before connecting an AI client, verify every item:

• [ ] WordPress, PHP and the MCP Adapter are on tested supported versions.
• [ ] HTTPS is enforced.
• [ ] The client uses a dedicated WordPress user.
• [ ] The user has the minimum required role and capabilities.
• [ ] A separate, revocable Application Password is used for each client or environment.
• [ ] No normal login password appears in MCP configuration.
• [ ] Secrets are excluded from repositories, screenshots and shared logs.
• [ ] Only necessary abilities have meta.public or meta.mcp.public enabled.
• [ ] Every ability has strict input and output schemas.
• [ ] Every ability has a permission callback.
• [ ] Object-level capability checks protect specific posts, products or records.
• [ ] Read, write and destructive operations are separate.
• [ ] Public-facing changes require human approval.
• [ ] Logs record the user, ability, time, arguments or argument hash, result and failure state.
• [ ] Sensitive prompt or customer data is redacted from logs.
• [ ] Rate limits and duplicate-request controls are in place.
• [ ] Revocation has been tested by deleting the Application Password.
• [ ] Backups and rollback procedures are operational.
• [ ] The integration has been tested against prompt injection in external content.

Logging and observability

The default MCP server uses an error-log handler for diagnostics and a null observability handler for request events. Developers can replace the observability handler with a custom implementation through mcp_adapter_default_server_config.[^18]

use WP\MCP\Infrastructure\ErrorHandling\ErrorLogMcpErrorHandler;
use WP\MCP\Infrastructure\Observability\ErrorLogMcpObservabilityHandler;

add_filter( 'mcp_adapter_default_server_config', function ( array $config ): array {
    $config['error_handler'] = ErrorLogMcpErrorHandler::class;
    $config['observability_handler'] = ErrorLogMcpObservabilityHandler::class;
    return $config;
} );

Avoid permanent verbose logging of full article bodies, customer records, credentials or model conversations. In production, send structured security events to an appropriate logging system and apply retention controls.

Revocation procedure

If a credential is exposed or a client is no longer approved:

1. Revoke its Application Password immediately. 2. Disable the associated user if compromise is suspected. 3. Remove or privatize exposed abilities. 4. Review WordPress, web-server and MCP observability logs. 5. Inspect posts, products, users and settings changed during the relevant period. 6. Rotate related credentials and restore from backup if necessary.

Troubleshooting

Endpoint not found

Symptoms: HTTP 404, rest_no_route, or a proxy report that the MCP server cannot be reached.

Check:

1. The MCP Adapter is activated. 2. The URL is exactly:

https://example.com/wp-json/mcp/mcp-adapter-default-server

3. The site's /wp-json/ endpoint is reachable. 4. WordPress permalinks are enabled; resave Settings → Permalinks if necessary. 5. A security plugin, reverse proxy, CDN or host is not blocking /wp-json/mcp/ or authenticated POST requests. 6. The WordPress subdirectory is included in the URL. 7. The client is not using the deprecated /wp-json/wp/v2/wpmcp/streamable route from another plugin.[^16]

Authentication failed

Symptoms: HTTP 401/403, warning icon in Claude Desktop, or "permission denied."

Check:

• WP_API_USERNAME is the real WordPress login name, not the Application Password label.
• WP_API_PASSWORD is the generated Application Password, not the normal account password.
• HTTPS is active.
• Basic Authorization headers reach WordPress; some proxies strip them.
• The user is active and has at least the server's required capability.
• The Application Password has not been revoked.

Spaces in the displayed Application Password can generally remain, but copying hidden characters or surrounding quotes into the secret value can cause failure.[^7]

Connected, but no useful abilities appear

The default server always centers on its three meta-tools, but only abilities marked public for MCP discovery will be returned.[^9]

Check:

• The custom plugin registering abilities is active.
• Registration runs on wp_abilities_api_init.
• meta.public or meta.mcp.public is true.
• meta.mcp.public is not explicitly false.
• The ability registration contains valid schemas and callbacks.
• The authenticated user passes the permission callback.

Use WP-CLI to separate client problems from WordPress problems:

echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | \
wp mcp-adapter serve \
  --server=mcp-adapter-default-server \
  --user=mcp-reader

Permission denied for one ability

This usually means transport authentication succeeded but the ability's permission callback rejected the current user or target object. That is expected security behavior.

Test:

• The dedicated role's capabilities
• Object-level access such as read_post or edit_post
• Whether the ability expects a different ID or input type
• Whether input validation failed before the permission callback

Do not "solve" the problem by replacing the permission callback with __return_true on a write ability.

Claude Desktop does not start the server

Check:

• The JSON is valid—no comments or trailing commas.
• wp, node and npx are in the application's executable path.
• Use absolute executable and log paths if necessary.
• Completely restart Claude Desktop.
• Inspect Claude Desktop developer logs and the proxy LOG_FILE.[^19][^7]

The remote proxy exits immediately

Run the underlying command in a terminal:

npx -y @automattic/mcp-wordpress-remote@latest

Then verify Node.js, DNS, TLS certificates, the MCP endpoint, username and Application Password. If an enterprise proxy is present, confirm that Node can reach the WordPress site.

HTTP session or initialization error

Streamable HTTP requires the MCP initialization sequence before normal tool requests. A raw tools/list POST without initialization may fail depending on client and adapter version. Use a compatible MCP client or start with the initialize request.[^9]

Wrong transport configuration

• Use direct WP-CLI STDIO when the client can execute WP-CLI on the same host or accessible local environment.
• Use the remote proxy when a STDIO-based client must reach WordPress over HTTP.
• Use a native remote connector only when the MCP endpoint and authentication mechanism are compatible and publicly reachable.

Do not point a local STDIO configuration directly at an HTTP URL without a proxy or native HTTP client.

FAQ

Is the WordPress MCP Adapter stable?

The plugin is publicly available as a canonical WordPress plugin, and version 0.7.0 marked a major distribution milestone. However, WordPress still describes it as experimental and is working toward version 1.0. Use it selectively in production, pin tested versions and maintain rollback procedures.

Do I need an AI provider connector to use MCP?

No. A provider connector allows WordPress to call OpenAI, Anthropic, Google or another model. With MCP, the model runs in Claude Desktop, Claude Code or another external client, while WordPress exposes approved abilities. Install a provider connector only if WordPress itself also needs to send model requests.

For the complete distinction, see Claude, Gemini and OpenAI in WordPress: AI Connectors, AI Client and MCP Explained.

Does MCP work with WooCommerce?

Yes, if WooCommerce abilities are supplied by a plugin or custom code. The MCP Adapter does not automatically create product, stock, order or customer tools. Begin with read-only product and stock abilities, then add approved write workflows only after permissions, validation, logs and rollback have been tested.

Does the adapter expose every WordPress ability?

No. Abilities are private by default. The default server discovers abilities marked with meta.public => true or meta.mcp.public => true; an explicit meta.mcp.public => false excludes an ability.[^2][^9]

Is `show_in_rest` the same as public MCP exposure?

No. show_in_rest controls the Abilities REST endpoints. MCP exposure uses the ability's public/MCP metadata. They can be enabled separately.[^6][^13]

Can Claude publish articles automatically?

Only if a write ability allows publishing and the authenticated user has permission. A safer initial design exposes draft creation but no publication action.

Can one WordPress MCP server serve several agents?

Yes, but use separate users and credentials so access can be attributed and revoked independently. For different trust levels, create separate custom MCP servers or ability sets rather than giving every client the same tools.

Is a WordPress administrator account required?

No. The server requires an authenticated user and each ability checks its own permissions. A dedicated lower-privilege or custom role is preferable.

Can Claude Desktop connect without exposing WordPress publicly?

For a local WordPress installation, Claude Desktop can launch WP-CLI over STDIO. Anthropic's cloud-brokered remote connectors require a publicly reachable MCP endpoint, whereas local claude_desktop_config.json subprocess servers can access local resources.[^17][^10]

Does MCP eliminate the need for the WordPress REST API?

No. The adapter's HTTP transport is registered through WordPress REST infrastructure, and abilities can separately be exposed through the Abilities REST API. MCP adds agent-oriented discovery and invocation; it does not replace every REST integration.[^6][^2]

Build a secure WordPress agent with Busony

A proof of concept can connect Claude to WordPress in an afternoon. A production agent requires more: ability design, custom roles, authentication, prompt-injection controls, WooCommerce safeguards, approval workflows, observability and recovery procedures.

Busony designs and implements controlled WordPress and WooCommerce agent systems, including:

• MCP Adapter installation and secure configuration
• Custom read, draft, publishing and commerce abilities
• Claude Desktop, Claude Code and agent-platform connections
• WordPress role and permission architecture
• WooCommerce product and stock workflows
• Human approval and audit trails
• Multilingual content and export automation
• AI Client and provider-connector integration
• Security reviews, staging tests and operational documentation

The recommended engagement starts with an MCP capability audit: identify the data and actions an agent needs, classify their risk, then expose only the minimum abilities required.

Contact Busony to design a WordPress MCP server or a controlled WooCommerce agent for your organization.

> Continue reading: Claude, Gemini and OpenAI in WordPress: AI Connectors, AI Client and MCP Explained covers the complete WordPress AI stack and explains when to use provider connectors, the canonical AI plugin, Abilities API or MCP.

References

[^1]: An MCP adapter that bridges the Abilities API to the Model Context Protocol — WordPress/mcp-adapter, GitHub. [^2]: README.md — WordPress/mcp-adapter, GitHub. [^3]: Abilities API – Common APIs Handbook — WordPress Developer Resources. [^4]: mcp-adapter readme.txt — WordPress/mcp-adapter, GitHub. [^5]: Getting started – Common APIs Handbook — WordPress Developer Resources. [^6]: REST API endpoints – Common APIs Handbook — WordPress Developer Resources. [^7]: Settings Menu Doesn't Show up on Hostinger Hosted WP (Issue #148) — WordPress/mcp-adapter, GitHub. [^8]: Getting started guide — WordPress/mcp-adapter, GitHub. [^9]: Default server guide — WordPress/mcp-adapter, GitHub. [^10]: CLI usage guide — WordPress/mcp-adapter, GitHub. [^11]: Architecture overview — WordPress/mcp-adapter, GitHub. [^12]: Transport & permissions guide — WordPress/mcp-adapter, GitHub. [^13]: Basic examples — WordPress/mcp-adapter, GitHub. [^14]: PHP reference – Common APIs Handbook — WordPress Developer Resources. [^15]: Hooks – Common APIs Handbook — WordPress Developer Resources. [^16]: Couldn't reach the MCP server (Issue #161) — WordPress/mcp-adapter, GitHub. [^17]: Get started with custom connectors using remote MCP — Anthropic Help Center. [^18]: Observability guide — WordPress/mcp-adapter, GitHub. [^19]: Getting Started with Local MCP Servers on Claude Desktop — Anthropic Help Center.