Convierte tu WordPress en un agente: guía del MCP Adapter oficial

Durante quince años, gestionar un WordPress ha significado lo mismo: entrar al escritorio, hacer clic, repetir. El MCP Adapter de WordPress rompe esa rutina. A partir de ahora tu web no es solo algo que tú manejas a mano: es algo que una IA puede entender, descubrir y operar por sí misma. Y lo bueno es que no hablamos de un experimento de garaje, sino del paquete oficial de WordPress.

Esta guía explica qué es, por qué importa y cómo dejarlo funcionando en tu sitio, con un ejemplo real de principio a fin.

Qué es exactamente el MCP Adapter

El MCP Adapter es un puente. De un lado tiene la Abilities API de WordPress; del otro, el Model Context Protocol (MCP), el estándar que usan los agentes de IA como Claude o Cursor para hablar con herramientas externas. El adaptador traduce las capacidades de tu WordPress a un lenguaje que la IA entiende y puede ejecutar.

Dicho de otro modo: registras una acción en WordPress (publicar un post, actualizar un producto, importar un feed inmobiliario) y el adaptador la expone automáticamente como una herramienta MCP que un agente puede invocar de forma segura.

Conviene tener clara la pareja de piezas que lo sostiene:

La Abilities API es el registro central de capacidades. Cada ability es una acción con nombre, descripción, esquema de entrada y salida, y un control de permisos. Llegó al núcleo de WordPress con la versión 6.9 (diciembre de 2025), así que si vas actualizado ya la tienes sin instalar nada extra.

El MCP Adapter es la capa que coge esas abilities y las publica como herramientas, recursos o prompts según la especificación MCP. Soporta transporte HTTP y STDIO, manejo de errores, validación y permisos granulares.

Por qué esto importa (y no es humo)

La diferencia entre "una web bonita" y "una web que trabaja sola" está justo aquí. Tres escenarios donde se nota de verdad:

Operar sin tocar el escritorio. Crear y editar entradas, lanzar consultas, gestionar contenido… todo desde tu cliente de IA, sin abrir el wp-admin. Para quien gestiona decenas de dominios, el ahorro de clics es brutal.

Acciones a medida por cliente. Una clínica dental puede tener una ability de "publicar artículo SEO con sus meta de Rank Math". Una inmobiliaria, una de "actualizar precios del feed". Tú las defines una vez y las disparas conversando.

Contenido real, no simulado. En lugar de generar un borrador y subirlo a mano, el agente escribe directamente en WordPress respetando permisos y validaciones. Lo que antes era una cadena de copia-pega ahora es una sola instrucción.

Y mirando al futuro: la Abilities API tiene previsto consolidarse aún más en el núcleo, lo que significa que cada plugin y cada tema podrá ofrecer capacidades de IA de forma nativa. Montar esto hoy es llegar temprano a algo que será estándar.

Requisitos antes de empezar

Antes de tocar nada, comprueba que cumples lo básico:

• PHP 7.4 o superior (recomendable 8.x).
• WordPress 6.9 o superior, donde la Abilities API ya viene en core. Si aún estás en 6.8, tendrás que instalar la Abilities API por separado.
• Composer instalado en el servidor o en tu entorno local.
• WP-CLI, muy recomendable para las pruebas por consola.
• Acceso para crear Application Passwords (contraseñas de aplicación), que es como se autentica la conexión por HTTP.

Un consejo sin rodeos: haz esto primero en local o en un staging, nunca directamente en producción. Estás abriendo una puerta para que una IA ejecute acciones; conviene probar la cerradura antes.

Instalación paso a paso

Vamos con el recorrido completo: instalar el adaptador, crear una ability de ejemplo y conectar el conjunto a Claude. Cada bloque es un paso; complétalo antes de pasar al siguiente.

Paso 1 — Instalar el MCP Adapter con Composer

La forma recomendada de instalarlo es como paquete de Composer dentro de tu plugin o tema. Desde la raíz de tu proyecto:

composer require wordpress/mcp-adapter

Si estás en WordPress 6.8 (sin Abilities API en core), instala ambos paquetes a la vez:

composer require wordpress/abilities-api wordpress/mcp-adapter

Nota sobre conflictos: si varios plugins van a usar el MCP Adapter en el mismo sitio, instala también el Jetpack Autoloader para evitar choques de versiones:

composer require automattic/jetpack-autoloader

Y en tu archivo principal carga vendor/autoload_packages.php en lugar del autoload estándar.

Cuando termine, ya tienes el adaptador disponible en tu proyecto. Confirma que el directorio vendor/ se ha creado y que el paquete wordpress/mcp-adapter aparece dentro antes de continuar.

Paso 2 — Inicializar el adaptador

El adaptador crea automáticamente un servidor por defecto, así que arrancarlo es de una línea. En el archivo principal de tu plugin:

<?php
use WP\MCP\Core\McpAdapter;

// Comprobamos que el adaptador está disponible
if ( ! class_exists( McpAdapter::class ) ) {
    // Aquí podrías mostrar un aviso en el admin si falta la dependencia
    return;
}

// Inicializamos el adaptador. Y ya está.
McpAdapter::instance();

Con esto el servidor por defecto queda accesible vía HTTP en una ruta del tipo:

/wp-json/mcp/mcp-adapter-default-server

Comprueba que la ruta responde (puedes visitarla en el navegador estando autenticado) antes de seguir.

Paso 3 — Registrar una ability de ejemplo

Aquí está la chicha. Vamos a registrar una ability que recupere las últimas entradas del sitio. Es el "hola mundo" perfecto: simple, seguro y útil. Añádelo en tu plugin:

add_action( 'wp_abilities_api_init', function () {
    wp_register_ability( 'costacx/get-posts', [
        'label'       => 'Obtener entradas',
        'description' => 'Recupera entradas de WordPress con filtros opcionales',
        'category'    => 'site',
        'input_schema' => [
            'type'       => 'object',
            'properties' => [
                'numberposts' => [
                    'type'        => 'integer',
                    'description' => 'Número de entradas a recuperar',
                    'default'     => 5,
                    'minimum'     => 1,
                    'maximum'     => 100,
                ],
                'post_status' => [
                    'type'        => 'string',
                    'description' => 'Estado de las entradas a filtrar',
                    'enum'        => [ 'publish', 'draft', 'private' ],
                    'default'     => 'publish',
                ],
            ],
        ],
        'output_schema' => [
            'type'  => 'array',
            'items' => [
                'type'       => 'object',
                'properties' => [
                    'ID'         => [ 'type' => 'integer' ],
                    'post_title' => [ 'type' => 'string' ],
                    'post_date'  => [ 'type' => 'string' ],
                ],
            ],
        ],
        'execute_callback' => function ( $input ) {
            return get_posts( [
                'numberposts' => $input['numberposts'] ?? 5,
                'post_status' => $input['post_status'] ?? 'publish',
            ] );
        },
        'permission_callback' => function () {
            return current_user_can( 'read' );
        },
        'meta' => [
            'mcp' => [
                'public' => true, // Necesario para que el servidor por defecto la exponga
            ],
        ],
    ] );
} );

Tres detalles que marcan la diferencia:

El input_schema y el output_schema describen qué entra y qué sale. La IA usa esto para saber cómo llamar a la ability sin adivinar nada.

El permission_callback es tu cerradura. Aquí defines quién puede ejecutarla; en el ejemplo, cualquiera con permiso de lectura. Para acciones de escritura, exige capacidades más fuertes.

El flag meta.mcp.public => true es lo que hace que el servidor por defecto la descubra. Sin él, la ability solo sería accesible desde servidores MCP personalizados.

Recarga WordPress y verifica que la ability se ha registrado antes de continuar (en el siguiente paso la veremos listada).

Paso 4 — Probar por consola con WP-CLI (STDIO)

Antes de conectar nada externo, conviene probar en local. El adaptador trae comandos de WP-CLI. Primero, lista los servidores disponibles:

wp mcp-adapter list

Luego, pide al servidor que descubra las abilities registradas. Esto te confirma que tu costacx/get-posts está vivo:

echo '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"mcp-adapter-discover-abilities","arguments":{}}}' | wp mcp-adapter serve --user=admin --server=mcp-adapter-default-server

Si en la respuesta aparece tu ability, vas por buen camino. No avances hasta verla en la lista.

Paso 5 — Conectar a Claude

Ahora la parte que da sentido a todo. Hay dos vías; elige según tu caso.

Opción A — STDIO (sitio local). Ideal si trabajas en tu máquina. En la configuración de tu cliente MCP (Claude Desktop, Claude Code, etc.), añade:

{
  "mcpServers": {
    "wordpress": {
      "command": "wp",
      "args": [
        "--path=/ruta/a/tu/wordpress",
        "mcp-adapter",
        "serve",
        "--server=mcp-adapter-default-server",
        "--user=admin"
      ]
    }
  }
}

Opción B — HTTP vía proxy (sitio remoto). Para un sitio que ya está en un servidor. Se usa un proxy que traduce STDIO a llamadas HTTP, autenticándose con una Application Password de WordPress:

{
  "mcpServers": {
    "wordpress-http": {
      "command": "npx",
      "args": [ "-y", "@automattic/mcp-wordpress-remote@latest" ],
      "env": {
        "WP_API_URL": "https://tu-sitio.com/wp-json/mcp/mcp-adapter-default-server",
        "WP_API_USERNAME": "tu-usuario",
        "WP_API_PASSWORD": "tu-application-password"
      }
    }
  }
}

Para generar la Application Password: en tu perfil de usuario de WordPress, busca la sección Contraseñas de aplicación, crea una nueva con un nombre descriptivo (por ejemplo, "Claude MCP") y copia el valor que te da. Guárdala bien: solo se muestra una vez.

Reinicia tu cliente MCP y, si todo está correcto, Claude verá tu WordPress como una herramienta más. Pídele algo tan simple como "dame mis últimas cinco entradas publicadas" y deberías ver cómo invoca tu ability.

Una advertencia que conviene leer dos veces

Esto no es "instalar plugin y olvidarse". Es una herramienta de desarrollador con consecuencias reales: estás autorizando a un agente de IA a ejecutar acciones sobre tu web. Por eso los permission_callback no son un trámite, son tu sistema de seguridad. Define permisos estrictos, empieza con abilities de solo lectura y ve ampliando con cabeza.

La regla de oro: cada ability de escritura debe verificar capacidades específicas (publish_posts, edit_posts, etc.). Una IA es rápida; un error de permisos también lo es.

Conclusión

El MCP Adapter no es una moda pasajera: es el camino oficial por el que WordPress se conecta al mundo de los agentes de IA. Hoy te permite operar tu web conversando; mañana será la base de cómo se gestionan los sitios. Montarlo ahora, aunque tenga su curva, es posicionarte donde el resto llegará dentro de un año.

Empieza pequeño, con una ability de lectura, comprueba cada paso y amplía a tu ritmo. La puerta ya está abierta; tú decides qué dejas pasar por ella.