WP-MCP

Gestiona y publica contenido de WordPress directamente desde tu asistente de IA, sin necesidad de PHP. Compatible con STDIO y Streamable HTTP para una amplia compatibilidad con clientes.

GitHub

Prueba este MCPPatrocinado

Documentación

wp-mcp

@rnaga/wp-mcp es un servidor del Protocolo de Contexto de Modelos (MCP) para WordPress que convierte tu sitio en una superficie operable por IA. Al exponer primitivas CRUD de WordPress a clientes como Claude Desktop, un asistente puede redactar una entrada bajo demanda, refinarla de forma colaborativa y publicarla directamente en tu base de datos, sin pasar por wp-admin.

Aquí hay algunos escenarios comunes que esto permite:

Redactar, revisar y publicar entradas directamente desde clientes MCP como Claude Desktop.
Inspeccionar usuarios de WordPress, sus roles y capacidades para auditar permisos del sitio o generar informes de acceso.

Construido sobre @rnaga/wp-node, el servidor incluye un conjunto de herramientas MCP seleccionadas que cubren entradas, usuarios, comentarios, términos, revisiones, metadatos, opciones y ajustes del sitio. El servidor MCP puede gestionar las siguientes tablas/recursos de la base de datos:

Recurso	Qué puedes hacer
Entradas	Crear, actualizar, leer o eliminar entradas y sus revisiones.
Comentarios	Moderar hilos de discusión o inyectar respuestas generadas.
Usuarios	Incorporar colaboradores, ajustar roles o desactivar cuentas con comprobaciones nativas de capacidades.
Términos	Gestionar categorías, etiquetas y taxonomías personalizadas.
Metadatos	Inspeccionar, crear, actualizar o eliminar campos meta de entradas, usuarios, comentarios, términos y sitio.
Ajustes y opciones	Cambiar la configuración a nivel de sitio de forma segura.

Puedes levantar un servidor STDIO para acceso directo a la base de datos u hospedar un servidor MCP HTTP Streamable para acceso remoto. Para mayor comodidad, añade el proxy CLI cuando tu cliente MCP necesite un puente local hacia el servidor HTTP. El proxy se comporta como un servidor MCP local mientras reenvía solicitudes al endpoint HTTP, perfecto para clientes que no admiten OAuth ni contraseñas de aplicación de WordPress, de modo que puedes integrar flujos de trabajo MCP en los pipelines editoriales existentes sin reimplementar la lógica de negocio de WordPress.

El proyecto incluye una CLI (wp-mcp) que te ayuda a:

configurar y lanzar un servidor MCP STDIO local que se conecta directamente a tu base de datos de WordPress;
generar e inicializar un servidor MCP HTTP Streamable basado en Express (con plantillas de entorno/TypeScript);
autenticarte contra un entorno WordPress remoto (OAuth o contraseña de aplicación) y ejecutar un proxy JSON-RPC para que los clientes MCP puedan alcanzarlo de forma segura;
inspeccionar las primitivas MCP disponibles y gestionar las credenciales almacenadas en ~/.wp-mcp.

Ejecuta este comando para listar los comandos CLI disponibles:

npx @rnaga/wp-mcp -- --help

Usage: <command> <subcommand> [options]

Commands:
   local            Local MCP (stdio) server commands
   utils            Utility commands for configuration, debugging, and MCP inspection
   http             Scaffold a TypeScript project for the MCP streamable HTTP server and related tooling.
   remote           Remote MCP server commands

En conjunto, el servidor, las utilidades CLI y las herramientas de proxy te permiten hacer CRUD de contenido de WordPress, gestionar usuarios y sincronizar ajustes mediante el estándar MCP sin reimplementar la lógica de WordPress.

Primeros pasos

Servidor STDIO local

Ejecuta el servidor STDIO cuando puedas acceder directamente a la base de datos. La CLI lanza un proceso MCP que asume un usuario de WordPress localmente y expone las herramientas de tu sitio a través de STDIO al cliente MCP.

flowchart LR
  client(["MCP Client<br/>(e.g. Claude Desktop)"])
  stdio(["Local STDIO MCP Server<br/>(wp-mcp CLI)"])
  db(["WordPress Database"])

  client <--> stdio
  stdio <--> db

Ejecuta la CLI para configurar la conexión a la base de datos:
```
npx @rnaga/wp-mcp -- local config-set
```
La CLI te solicita host, port, database name, user y password. Si tu base de datos requiere SSL, puedes proporcionar rutas de archivos CA, cert y key para asegurar el acceso remoto. Ejecuta npx @rnaga/wp-mcp local config en cualquier momento para revisar los valores guardados.
Configura tu cliente MCP para lanzar el servidor. Para Claude Desktop, abre Configuración → Desarrollador → Editar configuración y añade esto a tu claude_desktop_config.json:
```
{
  "mcpServers": {
    "wp-mcp": {
      "command": "npx",
      "args": ["-y", "@rnaga/wp-mcp", "--", "local", "start"],
      "env": {
        "LOCAL_USERNAME": "wp-admin"
      }
    }
  }
}
```
Activa el servidor: Guarda el archivo de configuración, luego cierra y reinicia tu cliente MCP (por ejemplo, Claude Desktop). Las herramientas de WordPress aparecerán ahora en el indicador MCP en la parte inferior derecha de la entrada de chat.

Importante: Reemplaza wp-admin con tu nombre de usuario de WordPress. El servidor lo usa para determinar qué primitivas MCP están disponibles según las capacidades del usuario de WordPress. Por ejemplo, los roles de administrador obtienen acceso completo a todas las primitivas (crear, actualizar, eliminar entradas, gestionar usuarios, etc.), mientras que los roles de suscriptor solo ven herramientas limitadas. Este filtrado basado en capacidades evita la ejecución accidental de operaciones privilegiadas. Para ver qué primitivas están disponibles y las capacidades y roles requeridos para cada una:
```
npx @rnaga/wp-mcp -- utils list-prims
```
Esto muestra una tabla con el nombre de la primitiva, título, descripción, capacidades requeridas y roles permitidos.

Opcional: Proporciona un manifiesto de configuración de WordPress si tu proyecto define uno (p. ej., src/_wp/config/wp.json). Establece LOCAL_CONFIG en el objeto env anterior a la ruta absoluta de tu archivo de configuración. Si no tienes una configuración personalizada, omite esta variable de entorno por completo. Para el esquema del manifiesto de configuración, consulta https://rnaga.github.io/wp-node/docs/getting-started/configuration.

Prueba del servidor MCP:

Usa el Inspector MCP para pruebas interactivas y depuración:
```
npx -y @modelcontextprotocol/inspector npx @rnaga/wp-mcp local start -u wp-admin
```
Esto abre una interfaz visual en http://localhost:6274 donde puedes explorar las herramientas disponibles, probarlas con diferentes argumentos e inspeccionar las respuestas del servidor.

Nota: El Inspector persiste su panel "Variables de entorno" en el almacenamiento del navegador entre sesiones. Si previamente añadiste una entrada PATH allí durante la resolución de problemas, elimínala manualmente en la interfaz: un valor obsoleto puede ocultar el entorno que el servidor realmente necesita y no será sobrescrito por las banderas de la CLI ni por cambios en los scripts.

Referencia de uso de banderas CLI y variables de entorno:

Variable de entorno	Bandera CLI	Propósito	Cuándo se lee
`LOCAL_USERNAME`	`--username <value>` / `-u <value>`	Nombre de usuario de WordPress a asumir	Usada por `local start` para elegir el usuario de WP cuyos roles y capacidades determinan las primitivas MCP disponibles.
`LOCAL_CONFIG`	`--file <path>` / `-f <path>`	Ubicación del manifiesto de configuración de WordPress	Usada por `local start` para apuntar el hook de init a un JSON de configuración de WP personalizado.
`DB_ENVIRONMENT`, `WP_DB_HOST`, `WP_DB_PORT`, `WP_DB_NAME`, `WP_DB_USER`, `WP_DB_PASSWORD`, `LOCAL_MULTISITE`, `LOCAL_DEFAULT_BLOG_ID`, `LOCAL_DEFAULT_SITE_ID`, `LOCAL_SSL_ENABLED`, `LOCAL_SSL_CA_FILEPATH`, `LOCAL_SSL_CERT_FILEPATH`, `LOCAL_SSL_KEY_FILEPATH`	(asistente vía `local config-set`)	Detalles de conexión a la base de datos local	Cargadas por el almacén de secretos antes de `local start`; complétalas con `local config-set` o expórtalas con antelación.

Servidor MCP HTTP Streamable

Usa el servidor HTTP cuando necesites exponer MCP a través de Internet o permitir que compañeros remotos se conecten. La CLI genera una aplicación Express (consulta src/http/express/index.ts) que expone tanto el transporte HTTP de streaming MCP como el respaldo SSE, reutilizando el mismo registro de primitivas.

Genera un proyecto
```
npx @rnaga/wp-mcp -- http init
```
El asistente solicita los detalles de conexión a la base de datos, crea un proyecto wp-node e incluye el boilerplate de Express más la configuración de TypeScript para el transporte HTTP.

Estructura resultante:
```
├── _wp
│   ├── config
│   │   ├── index.d.ts
│   │   └── wp.json
│   └── settings.ts
├── .env
├── .gitignore
├── index.ts
├── package-lock.json
├── package.json
├── src
│   └── index.ts
└── tsconfig.json
```
Completa .env con los valores solicitados por el generador y cualquier variable de entorno específica de HTTP que se liste más adelante en este documento.
Ejecuta el servidor en desarrollo
```
npm run dev
```
Esto depende de ts-node para que puedas iterar sin precompilar.
Compila y ejecuta en producción
```
npm run build
npm run start
```
La salida compilada inicia el mismo servidor Express que createHttpServer ensambla en la biblioteca.

Conéctate mediante el proxy CLI remoto

Usa el proxy remoto cuando tu cliente MCP solo entienda STDIO o carezca de soporte completo de OAuth, pero el entorno WordPress esté disponible por HTTP. El proxy mantiene las credenciales en ~/.wp-mcp y reenvía las solicitudes MCP al servidor remoto con el encabezado Authorization correcto.

flowchart LR
  client(["MCP Client<br/>(e.g. Claude Desktop)"])
  proxy(["CLI Proxy<br/>(handles OAuth<br/>or WP Application Password)"])
  server(["MCP HTTP Server<br/>(Express instance in this repo)"])
  db(["WordPress Database"])

  client <--> proxy
  proxy <--> server
  server <--> db

Autentícate una vez

Comienza inscribiendo el proxy con credenciales de contraseña de aplicación de WordPress o con un flujo de dispositivo OAuth para que pueda firmar solicitudes en nombre de tu cliente MCP.
- Contraseña de aplicación de WordPress
```
npx @rnaga/wp-mcp -- remote login password
```
  Proporciona la URL de autorización de tu servidor (por ejemplo, http://localhost:3000), luego ingresa el nombre de usuario de WordPress y la contraseña de aplicación. Las credenciales se almacenan de forma segura para que las ejecuciones futuras del proxy puedan suministrar autenticación HTTP Basic automáticamente (las contraseñas de aplicación de WordPress se transmiten mediante el esquema Basic).
  
  Inspecciona los valores almacenados con:
```
npx @rnaga/wp-mcp -- remote config
```
- Flujo de dispositivo OAuth
```
npx @rnaga/wp-mcp -- remote login oauth
```
  La CLI llama a /auth/device/start, imprime el código de usuario y abre la URL de verificación en tu navegador. Después de completar el flujo de dispositivo, los tokens de acceso y actualización se escriben en ~/.wp-mcp. Puedes volver a ejecutar remote config o remote revoke-token según sea necesario.
Usa npx @rnaga/wp-mcp -- remote config-clear si alguna vez necesitas eliminar secretos almacenados.
Inicia el proxy

Configura Claude Desktop (u otro cliente MCP) de la misma manera que lo haces para el servidor STDIO local, pero apunta el comando al proxy:

{
  "mcpServers": {
    "wp-mcp": {
      "command": "npx",
      "args": ["-y", "@rnaga/wp-mcp", "--", "remote", "proxy"],
      "env": {
        "REMOTE_AUTH_TYPE": "oauth",
        "REMOTE_URL": "https://wp-mcp.example.com/mcp"
      }
    }
  }
}

Ajusta REMOTE_AUTH_TYPE (oauth o password) y REMOTE_URL para que coincidan con tu endpoint remoto. También puedes pasarlos en tiempo de ejecución con --authType y --remoteUrl. El proxy valida tus credenciales guardadas, renueva los tokens OAuth cuando están a menos de cinco minutos de expirar, y luego expone un servidor MCP STDIO local que delega cada llamada al transporte HTTP remoto.

Una vez en ejecución, tu cliente habla STDIO localmente mientras el proxy reenvía el tráfico al servidor Express remoto.

Detalles internos del servidor HTTP Streamable

La implementación de Streamable HTTP agrupa middleware de Express que arranca un contexto de WordPress en cada solicitud, registra tanto el transporte HTTP de streaming como el SSE, e incorpora caché y manejadores de metadatos OAuth. El servidor remoto opera como un servidor de recursos OAuth 2.0: los clientes deben proporcionar un token bearer o una contraseña de aplicación de WordPress, y el servidor nunca actúa como cliente OAuth. Los metadatos de descubrimiento se sirven desde /.well-known/oauth-protected-resource, manteniendo la implementación alineada con RFC 9728.

El helper de código de dispositivo de la CLI (npx @rnaga/wp-mcp -- remote login oauth) extiende las herramientas MCP con un flujo amigable para terminal. Se comunica con los endpoints /auth/device/* del servidor, almacena los tokens resultantes en la bóveda de secretos (~/.wp-mcp) y permite que el proxy renueve y adjunte credenciales bearer automáticamente.

Control de acceso

La capa HTTP aplica autenticación en /mcp y /sse para que solo los llamadores autorizados puedan negociar sesiones. Soporta:

Tokens Bearer OAuth – validados a través del proveedor configurado, con tokens de acceso mapeados a usuarios de WordPress antes de que la sesión MCP se inicialice.
Contraseñas de Aplicación de WordPress – aceptadas sobre autenticación HTTP Basic y verificadas antes de asumir el usuario de WordPress en el servidor.

Las solicitudes bearer fallidas reciben cabeceras WWW-Authenticate compatibles con RFC 6750 que incluyen la URI de autorización y los scopes solicitados para que los clientes puedan recuperarse correctamente.

Endpoints

Ruta	Propósito
`/mcp`	Transporte MCP HTTP transmisible para solicitudes cliente-servidor y gestión del ciclo de vida de sesiones.
`/sse`	Transporte SSE heredado para clientes que requieren eventos enviados por el servidor.
`/messages`	Permite a los clientes SSE enviar mensajes de usuario de vuelta al servidor.
`/auth/device/start`	Inicia el flujo de autorización de dispositivo OAuth.
`/auth/device/poll`	Consulta la finalización del flujo de dispositivo OAuth y devuelve tokens.
`/auth/refresh`	Intercambia un token de refresco por un nuevo token de acceso.
`/auth/revoke`	Revoca un token de acceso en el proveedor.
`/auth/userinfo`	Devuelve el usuario de WordPress asociado con la cabecera Authorization proporcionada.
`/auth/password`	Valida una Contraseña de Aplicación de WordPress y devuelve el usuario asociado.
`/.well-known/oauth-protected-resource`	Sirve metadatos de recursos OAuth para herramientas de descubrimiento.

Proveedores OAuth compatibles

El servidor incluye perfiles de proveedor para GitHub, Google y Auth0. Cada perfil encapsula la emisión de código de dispositivo, la consulta de tokens, el refresco y la lógica de revocación que se puede conectar al instanciar el servidor HTTP. Para usar un sistema de identidad diferente, proporcione su propia implementación de proveedor a través del mismo enganche y mantenga el resto del despliegue sin cambios.

Configuración de proveedores OAuth

Para habilitar la autenticación OAuth, debe registrar una aplicación con su proveedor elegido y configurar las credenciales en sus variables de entorno.

Configuración OAuth de GitHub

Crear una aplicación OAuth: Navegue a Configuración de Desarrollador de GitHub > Aplicaciones OAuth > "Nueva aplicación OAuth"
Configure su aplicación:
- Nombre de la aplicación: El nombre mostrado de su aplicación
- URL de página de inicio: La página de inicio de su aplicación
- URL de devolución de llamada de autorización: Su endpoint de devolución de llamada OAuth
Obtenga credenciales: Después de la creación, anote su ID de Cliente y genere un Secreto de Cliente

Establezca variables de entorno:

OAUTH_CLIENT_ID=your_github_client_id
OAUTH_CLIENT_SECRET=your_github_client_secret

Documentación: Documentación de Aplicaciones OAuth de GitHub

Configuración OAuth de Google

Acceda a Google Cloud Console: Vaya a Google Cloud Console
Cree credenciales OAuth: Navegue a Menú > APIs y Servicios > Credenciales > Crear Credenciales > ID de cliente OAuth
Configure la pantalla de consentimiento OAuth: Configure el nombre de la aplicación, el correo de soporte al usuario y la configuración de audiencia
Seleccione el tipo de aplicación: Elija el tipo apropiado (Aplicación web, Aplicación de escritorio, etc.)
Obtenga credenciales: Anote su ID de Cliente y Secreto de Cliente

Establezca variables de entorno:

OAUTH_CLIENT_ID=your_google_client_id
OAUTH_CLIENT_SECRET=your_google_client_secret

Documentación: Configuración de OAuth 2.0 en Google Cloud

Configuración OAuth de Auth0

Cree una aplicación: Registre una Aplicación Nativa en su Panel de Auth0
Configure tipos de concesión: En Configuración de la Aplicación > Avanzado > Tipos de Concesión, habilite:
- Código de Dispositivo (requerido para el flujo de dispositivo)
- Token de Refresco (opcional, para refresco de tokens)
Habilite OIDC Conformant: En Configuración de la Aplicación > Avanzado > OAuth, asegúrese de que OIDC Conformant esté habilitado
Configure conexiones: Establezca y habilite al menos una conexión para la aplicación
Obtenga credenciales: Anote su ID de Cliente, Secreto de Cliente y Dominio

Establezca variables de entorno:

OAUTH_DOMAIN=your-tenant.us.auth0.com
OAUTH_CLIENT_ID=your_auth0_client_id
OAUTH_CLIENT_SECRET=your_auth0_client_secret

Documentación: Flujo de Autorización de Dispositivo de Auth0

Referencia de uso para variables de entorno

El servidor HTTP carga su configuración desde variables de entorno—típicamente a través de un archivo .env local, el entorno de proceso heredado, o configuraciones proporcionadas por su plataforma de alojamiento.

Variable de entorno	Propósito	Valor de ejemplo	Cuándo se lee
`OAUTH_RESOURCE_URL`	URL pública del recurso protegido	`https://mcp.example.com`	Incluida en los metadatos de recursos OAuth y en las comprobaciones de protección contra rebinding de DNS.
`OAUTH_RESOURCE_NAME`	Nombre mostrado para el recurso protegido	`Example WordPress MCP`	Devuelto en los metadatos de descubrimiento.
`OAUTH_SCOPES_SUPPORTED`	Scopes separados por comas soportados por el recurso	`openid,offline_access,posts.read`	Anunciado en los metadatos de descubrimiento y en las cabeceras `WWW-Authenticate`.
`OAUTH_SERVICE_DOCUMENTATION_URL`	Enlace de documentación para el recurso	`https://docs.example.com/mcp`	Devuelto en los metadatos de descubrimiento.
`OAUTH_AUTHORIZATION_URL`	URL del servidor de autorización	`https://auth.example.com`	Enviado a los clientes en cabeceras de error y utilizado por la CLI al inicializar flujos de dispositivo.
`OAUTH_CLIENT_ID`	Identificador de cliente OAuth	`mcp-remote-server`	Pasado al proveedor al solicitar códigos de dispositivo o refrescar tokens (dependiente del proveedor).
`OAUTH_CLIENT_SECRET`	Secreto de cliente OAuth (si es requerido)	`super-secret-value`	Utilizado para proveedores que esperan clientes confidenciales durante el refresco de tokens.
`ALLOWED_CORS_ORIGINS`	Orígenes HTTP separados por comas permitidos para CORS	`https://claude.ai,https://inspector.modelcontext.com`	Configura la política CORS del servidor HTTP.
`ENABLE_DNS_REBINDING_PROTECTION`	Habilita la protección contra rebinding de DNS para transporte HTTP	`true`	Habilita la protección contra rebinding de DNS para el transporte HTTP transmisible.
`OAUTH_DOMAIN`	Dominio OAuth (específico de Auth0)	`sample.us.auth0.com`	Utilizado cuando el Proveedor Auth0 construye URLs de dispositivo y token.

Si se omite una variable, el servidor recurre a valores predeterminados seguros (por ejemplo, CORS predeterminado a *, protección contra rebinding de DNS deshabilitada, y metadatos OAuth omitidos). Establezca solo los valores que su proveedor requiera.

Desarrollo de Primitivas MCP Personalizadas

El Protocolo de Contexto de Modelo define tres primitivas de primera clase: herramientas (acciones invocables), recursos (activos legibles expuestos por URI) y prompts (secuencias de mensajes plantillados). defaultMcpPrimitives en este paquete actualmente incluye implementaciones de herramientas, pero el mismo patrón de decorador + registro le permite exponer recursos y prompts también. El flujo de trabajo a continuación cubre el andamiaje, la creación de una clase y su conexión a cada transporte.

1. Andamiar un proyecto

Use la CLI para inicializar el andamiaje de TypeScript e instalar dependencias.

Servidor STDIO local

npx @rnaga/wp-mcp -- local init

El comando implementado en src/cli/local.cli.ts instala @rnaga/wp-node y @rnaga/wp-mcp, coloca un src/index.ts inicial, copia tsconfig.json, crea un .gitignore, y añade scripts dev, build y start a package.json.

Estructura resultante:

├── package.json
├── src
│   └── index.ts
├── tsconfig.json
└── package-lock.json

Servidor HTTP transmisible

npx @rnaga/wp-mcp -- http init

Este subcomando (ver src/cli/http.cli.ts) ejecuta los prompts de WordPress, instala las mismas dependencias, copia la plantilla HTTP src/index.ts, y añade la configuración específica de MCP a .env o .env.<environment>. Después de que el andamiaje termine, puede ejecutar npm run dev para iniciar el transporte Express.

2. Implementar una clase de primitiva

Cree un archivo como src/mcp/example-suite.mcp.ts y añada una clase decorada con @mcp y @mcpBind. Cada método @mcpBind recibe la instancia del servidor MCP más metadatos de tiempo de ejecución para que pueda registrar herramientas, recursos o prompts en un solo lugar.

Vea el repositorio @modelcontextprotocol/typescript-sdk para uso completo del SDK y ejemplos de registro de primitivas.

import { z } from "zod";

import { mcp, mcpBind } from "@rnaga/wp-mcp/decorators";
import { Mcps } from "@rnaga/wp-mcp/mcp";
import type * as types from "@rnaga/wp-mcp/types";

@mcp("example_suite", {
  description: "Example bundle showing tools, resources, and prompts.",
})
export class ExampleSuiteMcp {
  @mcpBind("example_tool", {
    title: "List Options",
    description: "Return the WordPress options table as JSON.",
    capabilities: ["read"],
  })
  example(...args: types.McpBindParameters) {
    const [server, username, meta] = args;

    server.registerTool(
      meta.name,
      {
        title: meta.title,
        description: meta.description,
        inputSchema: undefined,
      },
      async () => {
        const wp = await Mcps.getWpContext(username);
        const options = await wp.utils.crud.options.getAll();

        return {
          content: [
            {
              type: "text",
              text: JSON.stringify(options, null, 2),
            },
          ],
        };
      }
    );

    return server;
  }
}

Cada manejador recibe la misma tupla:

server – la instancia de McpServer de @modelcontextprotocol/sdk/server/mcp.js, que expone registerTool, registerResource y registerPrompt.
username – la identidad de WordPress adjunta a la sesión; pásala a Mcps.getWpContext para aplicar comprobaciones de capacidades cuando toque las APIs de WordPress.
meta – los metadatos del decorador (name, title, description, capacidades, roles) que puede reutilizar al registrar primitivas.

Mcps.getWpContext produce el contexto @rnaga/wp-node hidratado. Úselo dentro de herramientas, recursos o prompts para llamar a ayudantes CRUD, recopilar metadatos del sitio, o aplicar lógica adicional antes de devolver respuestas MCP.

3. Registrar la clase con el punto de entrada del servidor

Ambos transportes exponen un array mcps; añada su clase para que el servidor la conecte al iniciarse. Todas las primitivas registradas dentro de los métodos de la clase (herramientas, recursos, prompts) estarán disponibles para los clientes MCP conectados.

Servidor STDIO local

import { createLocalServer } from "@rnaga/wp-mcp/cli/local";
import { ExampleSuiteMcp } from "./example-suite.mcp";

(async () => {
  const mcpServer = await createLocalServer({
    username: process.env.LOCAL_USERNAME,
    mcps: [ExampleSuiteMcp],
  });

  // connect transport...
})();

Servidor HTTP transmisible

import { MemoryCache } from "@rnaga/wp-mcp/http/cache/memory-cache";
import { createHttpServer } from "@rnaga/wp-mcp/http/express";
import { ExampleSuiteMcp } from "./example-suite.mcp";

const app = createHttpServer({
  cacheClass: MemoryCache,
  mcps: [ExampleSuiteMcp],
});

Inicie el servidor (npm run dev localmente o npm start después de compilar) y las herramientas, recursos y prompts registrados aparecerán para cualquier cliente MCP conectado a través del proxy local o transporte HTTP.

Registro MCP

Este servidor está publicado en el Registro del Protocolo de Contexto de Modelo, lo que lo hace fácilmente descubrible e instalable por clientes MCP.

Puede encontrar el servidor en: https://registry.modelcontextprotocol.io/v0/servers?search=wp-mcp&version=latest

La entrada del registro incluye detalles de configuración, variables de entorno requeridas e instrucciones de instalación.