WordPress MCP Adapter: cómo convertir Abilities en herramientas para agentes de IA

Desde WordPress 6.9, la Abilities API permite registrar “cosas que tu sitio puede hacer” de forma estandarizada, descubrible, tipada y ejecutable. Esto no solo mejora la interoperabilidad entre Core, plugins y diferentes contextos (PHP, JavaScript, REST API), sino que además coloca a WordPress en una posición muy buena para automatización y flujos de trabajo con IA generativa.

En paralelo, el ecosistema de agentes ha convergido en un concepto clave: dar contexto y capacidades de forma segura a los modelos. Ahí entra en juego el Model Context Protocol (MCP), un protocolo que define cómo un cliente de IA descubre y usa herramientas (tools), lee datos (resources) y sigue guías predefinidas (prompts).

La pieza que conecta ambos mundos es el WordPress MCP Adapter: un adaptador oficial que “traduce” Abilities al vocabulario de MCP para que clientes como Claude Desktop, Claude Code, Cursor y VS Code puedan descubrir y ejecutar Abilities directamente.

Recap rápido: Abilities como base funcional en WordPress

La Abilities API le da a WordPress una API funcional de primera clase y multi-contexto, que estandariza cómo Core y los plugins exponen lo que son capaces de hacer.

Una Ability se define una única vez y queda disponible para ser descubierta y ejecutada desde PHP, JavaScript y la REST API. Para registrarla necesitas:

Un nombre único (namespace/ability-name).
Un schema de entrada tipado y un schema de salida tipado.
Un permission_callback para aplicar las capacidades/permisos.
Un execute_callback con la implementación real de la funcionalidad.

El código dentro de execute_callback puede hacer prácticamente cualquier unidad discreta de trabajo: leer datos, actualizar posts, lanzar diagnósticos, etc.

WordPress 6.9 incluye 3 Abilities por defecto (perfectas para hacer pruebas iniciales):

core/get-site-info: devuelve información del sitio configurada en WordPress. Por defecto devuelve todos los campos, o un subconjunto filtrado opcional.
core/get-user-info: devuelve detalles básicos del perfil del usuario autenticado actual para personalización, auditoría y comportamientos según acceso.
core/get-environment-info: devuelve detalles del contexto de ejecución para diagnóstico y compatibilidad (entorno, runtime de PHP, info del servidor de base de datos, versión de WordPress).

Qué es el WordPress MCP Adapter (y por qué importa)

El WordPress MCP Adapter forma parte del paquete oficial dentro de la iniciativa AI Building Blocks for WordPress. Su objetivo es adaptar las Abilities registradas con la Abilities API a las primitives de MCP, de forma que los agentes de IA puedan:

Descubrir y ejecutar funcionalidad del sitio como MCP tools (herramientas).
Leer datos de WordPress como MCP resources (recursos).

En la práctica, esto significa que si tu plugin ya registra Abilities, estás a un paso de que un agente de IA pueda utilizarlas.

MCP en tres piezas: tools, resources y prompts

MCP organiza las interacciones en tres primitives principales:

Tools: funciones ejecutables que el cliente de IA llama para realizar acciones.
Resources: fuentes de datos pasivas (por ejemplo, archivos o filas de base de datos) que el cliente lee como contexto.
Prompts: plantillas preconfiguradas para guiar flujos de trabajo concretos.

Con el MCP Adapter, lo habitual es exponer Abilities como tools, porque representan lógica ejecutable: consultar datos, actualizar contenido o ejecutar diagnósticos. Pero el adaptador es flexible: si una Ability es solo lectura y su función es aportar contexto (por ejemplo, un log de depuración o una configuración estática), también puede configurarse como resource para que la IA lo “ingiera” como contexto sin necesidad de invocarla como herramienta.

Instalación rápida del MCP Adapter (como plugin)

La forma más directa de empezar es instalarlo como plugin descargándolo desde la página de releases del repositorio en GitHub: https://github.com/WordPress/mcp-adapter/releases.

Al activarlo, el plugin registra:

Un servidor MCP por defecto llamado mcp-adapter-default-server.
Tres Abilities propias del adaptador: mcp-adapter/discover-abilities, mcp-adapter/get-ability-info, mcp-adapter/execute-ability.

Y además las expone automáticamente como herramientas MCP (tools):

mcp-adapter-discover-abilities
mcp-adapter-get-ability-info
mcp-adapter-execute-ability

Estas tres tools permiten un acceso por capas a las Abilities: el agente puede descubrir qué hay disponible, inspeccionar una Ability y finalmente ejecutarla.

Cómo habilitar Abilities en el servidor MCP por defecto

Por diseño, el servidor por defecto no expone Abilities automáticamente: solo estarán disponibles vía mcp-adapter-default-server si las marcas explícitamente como públicas para MCP. Para eso debes añadir la bandera meta.mcp.public en los argumentos de registro cuando uses wp_register_ability():

'meta' => array(
    'mcp' => array(
        'public' => true,  // Required for MCP default server access
    ),
)

'meta' => array(
    'mcp' => array(
        'public' => true,  // Required for MCP default server access
    ),
)

Si quieres habilitar Abilities de Core (las tres que vienen por defecto), puedes engancharte al filtro wp_register_ability_args y modificar los argumentos de registro para incluir meta.mcp.public:

<?php
/**
 * Plugin Name: Enable core abilities
 * Version: 1.0.0
 *
 * @package enable-core-abilities
 */

add_filter( 'wp_register_ability_args', 'myplugin_enable_core_abilities_mcp_access', 10, 2 );
/**
 * Enable MCP access for core abilities.
 *
 * @param array  $args        Ability registration arguments.
 * @param string $ability_name  Ability ID.
 * @return array Modified ability registration arguments.
 */
function myplugin_enable_core_abilities_mcp_access( array $args, string $ability_name ) {
    // Enable MCP access for the three current core abilities.
    $core_abilities = array(
        'core/get-site-info',
        'core/get-user-info',
        'core/get-environment-info',
    );
    if ( in_array( $ability_name, $core_abilities, true ) ) {
        $args['meta']['mcp']['public'] = true;
    }

    return $args;
}

<?php
/**
 * Plugin Name: Enable core abilities
 * Version: 1.0.0
 *
 * @package enable-core-abilities
 */

add_filter( 'wp_register_ability_args', 'myplugin_enable_core_abilities_mcp_access', 10, 2 );
/**
 * Enable MCP access for core abilities.
 *
 * @param array  $args        Ability registration arguments.
 * @param string $ability_name  Ability ID.
 * @return array Modified ability registration arguments.
 */
function myplugin_enable_core_abilities_mcp_access( array $args, string $ability_name ) {
    // Enable MCP access for the three current core abilities.
    $core_abilities = array(
        'core/get-site-info',
        'core/get-user-info',
        'core/get-environment-info',
    );
    if ( in_array( $ability_name, $core_abilities, true ) ) {
        $args['meta']['mcp']['public'] = true;
    }

    return $args;
}

Con esto ya puedes conectar un cliente MCP a tu WordPress y ejecutar esas Abilities vía las tools del servidor por defecto.

Conectar aplicaciones de IA: STDIO vs HTTP

Para hablar con un WordPress que actúa como servidor MCP existen dos mecanismos de transporte: STDIO y HTTP. La elección suele depender de dónde está tu WordPress (local vs público) y de si quieres evitar el transporte por consola.

Transporte STDIO (ideal para desarrollo local)

En entornos locales, lo más sencillo suele ser STDIO. El MCP Adapter lo soporta usando WP-CLI (así que necesitas WP-CLI instalado en tu máquina). Una configuración mínima para conectar con tu servidor MCP de WordPress tendría este aspecto:

"wordpress-mcp-server": {
  "command": "wp",
  "args": [
    "--path=/path/to/your/wordpress/installation",
    "mcp-adapter",
    "serve",
    "--server=mcp-adapter-default-server",
    "--user={admin_user}"
  ]
}

"wordpress-mcp-server": {
  "command": "wp",
  "args": [
    "--path=/path/to/your/wordpress/installation",
    "mcp-adapter",
    "serve",
    "--server=mcp-adapter-default-server",
    "--user={admin_user}"
  ]
}

Detalles importantes de esa configuración:

wordpress-mcp-server es solo un nombre interno: puedes usar el que quieras.
command es wp, el binario de WP-CLI.
En args: --path apunta a tu instalación de WordPress.
mcp-adapter serve arranca el servidor del adaptador.
--server define qué servidor MCP usar (aquí el de por defecto).
--user define con qué usuario de WordPress se autentica el cliente (por ejemplo, un admin en local).

Transporte HTTP (instalaciones públicas o sin STDIO)

Si tu WordPress es accesible públicamente, o si prefieres no depender de STDIO, puedes usar HTTP a través del proxy remoto @automattic/mcp-wordpress-remote. Esto requiere Node.js instalado y configurar autenticación con application passwords o una implementación OAuth propia.

Configuración mínima (HTTP) típica:

"wordpress-mcp-server": {
  "command": "npx",
  "args": ["-y", "@automattic/mcp-wordpress-remote@latest"],
  "env": {
    "WP_API_URL": "https://yoursite.example/wp-json/mcp/mcp-adapter-default-server",
    "WP_API_USERNAME": "{admin_user}",
    "WP_API_PASSWORD": "{application-password}"
  }
}

"wordpress-mcp-server": {
  "command": "npx",
  "args": ["-y", "@automattic/mcp-wordpress-remote@latest"],
  "env": {
    "WP_API_URL": "https://yoursite.example/wp-json/mcp/mcp-adapter-default-server",
    "WP_API_USERNAME": "{admin_user}",
    "WP_API_PASSWORD": "{application-password}"
  }
}

Qué significa cada parte:

El nombre del servidor puede mantenerse como wordpress-mcp-server.
command es npx, que ejecuta paquetes de Node.js.
-y acepta automáticamente la instalación del paquete.
@automattic/mcp-wordpress-remote@latest usa la última versión del proxy remoto.
En env: WP_API_URL apunta al endpoint MCP de tu WordPress.
WP_API_USERNAME es el usuario con el que autenticas.
WP_API_PASSWORD es el application password de ese usuario.

Si conectas un WordPress local vía HTTP usando el proxy remoto y te encuentras con problemas, el paquete incluye una guía de troubleshooting: https://github.com/Automattic/mcp-wordpress-remote/blob/trunk/Docs/troubleshooting.md. Los fallos más habituales suelen venir de tener varias versiones de Node.js instaladas o de certificados SSL locales.

Configuración por aplicación: Claude Desktop, Cursor, Claude Code y VS Code

Cada cliente de IA coloca la configuración en un sitio distinto, pero el formato base de definición del servidor MCP es prácticamente el mismo (con un pequeño matiz en VS Code).

Claude Desktop

Claude Desktop tiene soporte integrado de MCP. Para añadir servidores MCP, ve a la pestaña Developer (Claude → Settings → Developer) y en Local MCP servers pulsa Edit config. Esto abre el archivo claude_desktop_config.json, donde puedes añadir servidores dentro de un objeto mcpServers:

{
  "mcpServers": {
  }
}

{
  "mcpServers": {
  }
}

Ejemplo con transporte STDIO:

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

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

Ejemplo con transporte HTTP:

{
  "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"
      }
    }
  }
}

{
  "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"
      }
    }
  }
}

Después de guardar el archivo, es necesario reiniciar Claude Desktop, porque solo carga la configuración de servidores MCP al arrancar. Cuando todo está bien, verás el servidor en Local MCP servers con estado running.

Claude Desktop mostrando el servidor MCP de WordPress añadido en Local MCP servers — *Forrás: WordPress Developer Blog*

Cursor

En Cursor, entra en Settings (Cursor → Settings → Cursor Settings) y abre la sección Tools and MCP. Allí pulsa Add Custom MCP: se abrirá el archivo mcp.json donde defines el servidor.

La configuración es la misma que en Claude Desktop. Guardas, vuelves a la sección Tools and MCP, y ya debería aparecer el servidor para poder habilitarlo en tus sesiones de código.

Cursor mostrando el servidor MCP de WordPress añadido en Tools and MCP — *Forrás: WordPress Developer Blog*

Claude Code

En Claude Code tienes dos opciones para añadir servidores MCP:

Añadir el objeto mcpServers con las configuraciones al archivo .claude.json en tu directorio home (disponible globalmente).
Crear un archivo .mcp.json dentro del directorio del proyecto (configuración por proyecto).

En ambos casos, el formato del servidor es el mismo que en Cursor o Claude Desktop.

VS Code

VS Code requiere un archivo JSON (normalmente mcp.json) dentro de una carpeta .vscode en el workspace del proyecto. La referencia para este formato está aquí: https://code.visualstudio.com/docs/copilot/customization/mcp-servers.

La diferencia clave respecto a Claude Desktop/Cursor es que VS Code usa un objeto servers en lugar de mcpServers:

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

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

Cuando el archivo está en su sitio, VS Code muestra una barra de control MCP para iniciar, parar o reiniciar el servidor. Si arranca correctamente, también muestra cuántas tools están disponibles (por ejemplo, 3 en el caso del servidor por defecto).

VS Code mostrando un archivo mcp.json con la configuración del servidor MCP de WordPress — *Forrás: WordPress Developer Blog*

Cómo se usan las MCP tools en la práctica

Una vez conectado tu servidor MCP al cliente de IA, ya puedes usar las herramientas expuestas por el MCP Adapter. Por ejemplo, en Claude Desktop puedes pedir algo como: “Get the site info from my WordPress site”.

Consulta en Claude Desktop que usa tools MCP para obtener información del sitio desde WordPress — *Forrás: WordPress Developer Blog*

El flujo típico es:

El cliente detecta que hay un servidor MCP disponible.
Invoca mcp-adapter-discover-abilities para ver qué Abilities están expuestas.
Decide qué Ability resuelve la petición (por ejemplo core/get-site-info).
Invoca mcp-adapter-execute-ability pasando el nombre de la Ability.
El servidor devuelve datos, y el cliente los presenta como respuesta.

Servidores MCP personalizados dentro de tus plugins

El servidor por defecto (mcp-adapter-default-server) cubre muchos casos, pero a veces interesa definir un servidor MCP específico para tu plugin. Esto te da más control sobre qué Abilities expones y cómo las presentas al cliente.

Para hacerlo, la idea es instalar el MCP Adapter como dependencia con Composer, cargar el autoloader e inicializar el adaptador desde tu plugin.

1) Instalar la dependencia con Composer

Desde el directorio del plugin:

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

2) Cargar el autoloader de Composer

En el archivo principal del plugin, asegúrate de cargar el autoloader:

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

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

Si existe la posibilidad de que múltiples plugins dependan del MCP Adapter o de la Abilities API, se recomienda usar Jetpack Autoloader para evitar conflictos de versiones: https://github.com/WordPress/mcp-adapter/blob/trunk/docs/getting-started/installation.md#using-jetpack-autoloader-highly-recommended.

3) Inicializar el MCP Adapter

if ( ! class_exists( WPMCPCoreMcpAdapter::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.
WPMCPCoreMcpAdapter::instance();

if ( ! class_exists( WPMCPCoreMcpAdapter::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.
WPMCPCoreMcpAdapter::instance();

4) Crear y registrar tu servidor MCP (hook mcp_adapter_init)

Para crear el servidor personalizado, usa la acción mcp_adapter_init. El callback recibe la instancia de McpAdapter. Con create_server() defines el servidor y su configuración:

add_action( 'mcp_adapter_init', 'myplugin_create_custom_mcp_server' );
function myplugin_create_custom_mcp_server( $adapter ) {
    $adapter = WPMCPCoreMcpAdapter::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.
            WPMCPTransportHttpTransport::class,  // Recommended: MCP 2025-06-18 compliant.
        ),
        WPMCPInfrastructureErrorHandlingErrorLogMcpErrorHandler::class, // Error handler.
        WPMCPInfrastructureObservabilityNullMcpObservabilityHandler::class, // Observability handler.
        array( 'namespace/ability-name' ), // Abilities to expose as tools
        array(),                           // Resources (optional).
        array(),                           // Prompts (optional).
    );
}

add_action( 'mcp_adapter_init', 'myplugin_create_custom_mcp_server' );
function myplugin_create_custom_mcp_server( $adapter ) {
    $adapter = WPMCPCoreMcpAdapter::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.
            WPMCPTransportHttpTransport::class,  // Recommended: MCP 2025-06-18 compliant.
        ),
        WPMCPInfrastructureErrorHandlingErrorLogMcpErrorHandler::class, // Error handler.
        WPMCPInfrastructureObservabilityNullMcpObservabilityHandler::class, // Observability handler.
        array( 'namespace/ability-name' ), // Abilities to expose as tools
        array(),                           // Resources (optional).
        array(),                           // Prompts (optional).
    );
}

Parámetros clave a vigilar en create_server():

1) Identificador único del servidor: se usa al arrancarlo vía WP-CLI.
2) y 3) Namespace y route de la REST API del servidor MCP.
4) y 5) Nombre y descripción: aparecen en los clientes de IA al listar servidores MCP.
6) Versión del servidor.
10) Lista de Abilities a exponer como tools (puedes poner varias).
El resto controla métodos de transporte, manejo de errores y observabilidad. Puedes usar los handlers del paquete o implementar los tuyos para integrarlo con tu transporte, logging o monitorización.

Ejemplo completo: añadir un servidor MCP al plugin “List All URLs”

Para aterrizarlo con un caso real, se puede tomar el plugin List All URLs y añadirle un servidor MCP personalizado que exponga su Ability como tool.

Repositorio del plugin: https://github.com/wptrainingteam/list-all-urls.

Antes de empezar

Desactiva el plugin MCP Adapter si lo tienes activo, para este ejemplo.

1) Clonar el repositorio en wp-content/plugins

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

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

2) Cambiar a la rama con Abilities API

cd list-all-urls
git checkout abilities

cd list-all-urls
git checkout abilities

3) Instalar dependencias y añadir mcp-adapter

Como ya usa Composer, instala dependencias y añade el adaptador:

composer install

composer install

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

4) Modificar list-all-urls.php para inicializar MCP y crear el servidor

Abre el archivo principal list-all-urls.php y añade al final este código para inicializar el adaptador y crear un servidor MCP propio:

if ( ! class_exists( WPMCPCoreMcpAdapter::class ) ) {
    return;
}

// Initialize MCP Adapter and its default server.
WPMCPCoreMcpAdapter::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 WPMCPCoreMcpAdapter The MCP Adapter instance.
 * @return void
 */
function list_all_urls_create_custom_mcp_server( $adapter ) {
    $adapter = WPMCPCoreMcpAdapter::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(
            WPMCPTransportHttpTransport::class,
        ),
        WPMCPInfrastructureErrorHandlingErrorLogMcpErrorHandler::class,
        WPMCPInfrastructureObservabilityNullMcpObservabilityHandler::class,
        array( 'list-all-urls/urls' ),
    );
}

if ( ! class_exists( WPMCPCoreMcpAdapter::class ) ) {
    return;
}

// Initialize MCP Adapter and its default server.
WPMCPCoreMcpAdapter::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 WPMCPCoreMcpAdapter The MCP Adapter instance.
 * @return void
 */
function list_all_urls_create_custom_mcp_server( $adapter ) {
    $adapter = WPMCPCoreMcpAdapter::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(
            WPMCPTransportHttpTransport::class,
        ),
        WPMCPInfrastructureErrorHandlingErrorLogMcpErrorHandler::class,
        WPMCPInfrastructureObservabilityNullMcpObservabilityHandler::class,
        array( 'list-all-urls/urls' ),
    );
}

Fíjate en un detalle importante: aquí no necesitas marcar meta.mcp.public en list-all-urls/urls, porque la Ability se está exponiendo explícitamente vía el servidor MCP personalizado.

5) Activar el plugin y apuntar tu cliente al nuevo servidor

Activa el plugin desde el admin de WordPress y actualiza la configuración MCP de tu cliente de IA para usar el servidor nuevo.

Ejemplo de mcp.json para VS Code incluyendo dos servidores (el default y el del plugin), ambos usando STDIO:

{
  "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"
      ]
    }
  }
}

{
  "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"
      ]
    }
  }
}

Puedes tener múltiples servidores MCP configurados en una misma aplicación: sirve para cambiar entre distintos sitios WordPress o entre plugins que expongan conjuntos diferentes de Abilities.

Tras cambiar configuración, recuerda reiniciar la aplicación o iniciar el servidor MCP desde la propia UI (según el cliente). Cuando esté listo, podrás pedir algo como “List all URLs on my WordPress site” y el cliente invocará la tool correspondiente (list-all-urls-urls) a través del MCP Adapter.

VS Code usando tools MCP para consultar las URLs listadas por el plugin List All URLs — *Forrás: WordPress Developer Blog*

Seguridad y buenas prácticas (imprescindible antes de exponer tools)

Un punto crítico: los clientes MCP actúan como usuarios autenticados de WordPress. Trátalos como parte de tu superficie de aplicación y aplica estas prácticas:

Usa permission_callback con cuidado.
Cada Ability debe comprobar la capacidad mínima necesaria (manage_options, edit_posts, etc.).
Evita __return_true en operaciones destructivas como borrar contenido.
Usa usuarios dedicados para acceso MCP.
Especialmente en producción, crea un rol/usuario específico con capacidades limitadas.
No expongas Abilities potentes a clientes de IA sin auditoría.
Prioriza Abilities de solo lectura para endpoints MCP públicos.
Para transportes HTTP expuestos en internet, céntrate en diagnósticos, reporting y acceso a contenido de lectura.
Implementa autenticación personalizada si lo necesitas.
La autenticación por defecto usa application passwords, pero puedes implementar OAuth u otros métodos para mayor seguridad.
Monitoriza y registra el uso.
Usa handlers personalizados de error y observabilidad para integrarlo con tu stack de logging/monitorización.

Cómo empezar hoy (camino mínimo “hello AI”)

Si quieres experimentar ya, el camino mínimo como desarrollador WordPress es bastante directo:

Registrar al menos una Ability en tu plugin.
Instalar/requerir e inicializar el MCP Adapter (como plugin o con Composer).
Conectar un cliente compatible con MCP (Claude Desktop, Cursor, VS Code, Claude Code).

Si ya tienes plugins construidos sobre Abilities, el MCP Adapter convierte esa capa en APIs listas para agentes de IA con muy poco trabajo adicional. Y como con cualquier tecnología nueva: empieza pequeño, con Abilities de solo lectura y no destructivas; prueba en local con clientes como Claude Desktop o Cursor; y escala a flujos más complejos a medida que ganes confianza.

Para profundizar en documentación: Abilities API en https://developer.wordpress.org/apis/abilities/ y MCP Adapter en https://github.com/WordPress/mcp-adapter.

WordPress MCP Adapter: cómo convertir Abilities en herramientas para agentes de IA

Recap rápido: Abilities como base funcional en WordPress

Qué es el WordPress MCP Adapter (y por qué importa)

MCP en tres piezas: tools, resources y prompts

Instalación rápida del MCP Adapter (como plugin)

Cómo habilitar Abilities en el servidor MCP por defecto

Conectar aplicaciones de IA: STDIO vs HTTP

Transporte STDIO (ideal para desarrollo local)

Transporte HTTP (instalaciones públicas o sin STDIO)

Configuración por aplicación: Claude Desktop, Cursor, Claude Code y VS Code

Claude Desktop

Cursor

Claude Code

VS Code

Cómo se usan las MCP tools en la práctica

Servidores MCP personalizados dentro de tus plugins

1) Instalar la dependencia con Composer

2) Cargar el autoloader de Composer

3) Inicializar el MCP Adapter

4) Crear y registrar tu servidor MCP (hook mcp_adapter_init)

Ejemplo completo: añadir un servidor MCP al plugin “List All URLs”

Antes de empezar

1) Clonar el repositorio en wp-content/plugins

2) Cambiar a la rama con Abilities API

3) Instalar dependencias y añadir mcp-adapter

4) Modificar list-all-urls.php para inicializar MCP y crear el servidor

5) Activar el plugin y apuntar tu cliente al nuevo servidor

Seguridad y buenas prácticas (imprescindible antes de exponer tools)

Cómo empezar hoy (camino mínimo “hello AI”)

Referencias / Fuentes

Laura Fernández

Más de Laura Fernández

¡Únete a la comunidad de HelloWP!