ZennoPoster MCP

Edita proyectos de automatización de ZennoPoster, ejecuta y monitorea tareas, controla instancias de navegador y dispositivos Android desde agentes de IA. Solo Windows, requiere ZennoPoster 7.9.2+.

GitHub

Documentación

Español | Русский

Conexión de los servidores MCP de ZennoPoster/ProjectMaker a tu propio cliente LLM

Los servidores MCP se publican como binarios autónomos win-x64 a través de GitHub Releases en el repositorio compartido https://github.com/ZennoLab/zennoposter-mcp/releases. Cada servidor tiene su propia línea de versiones (su propio prefijo de etiqueta):

ProjectMaker (editor) — etiquetas mcp-projectmaker-v*, archivo MCP.ProjectMaker-v*-win-x64.zip
Instance (control del navegador, doble montaje) — etiquetas mcp-instance-v*, archivo MCP.Instance-v*-win-x64.zip
ZennoPoster (ejecutor de tareas) — etiquetas mcp-zennoposter-v*, archivo MCP.ZennoPoster-v*-win-x64.zip
Android (dispositivo ZennoDroid) — etiquetas mcp-android-v*, archivo MCP.Android-v*-win-x64.zip

La documentación de PublicApi (el contrato OpenAPI renderizado con Redoc, la guía del integrador, los códigos de error, la política de versionado) se encuentra en https://zennolab.github.io/zennoposter-mcp/ (las páginas se publican desde la carpeta docs/ de este repositorio).

Estos servidores se comunican con ZennoPoster 7.9.2 y versiones posteriores y con ZennoDroid 2.6.1 y versiones posteriores. MCP.Instance se aplica solo a ZennoPoster y MCP.Android solo a ZennoDroid; MCP.ProjectMaker y MCP.ZennoPoster se aplican a ambos. Qué versión del servidor corresponde a cada producto y versión del contrato: https://zennolab.github.io/zennoposter-mcp/compatibility.html.

Botones de instalación para Cursor y VS Code y los comandos de Claude Code para cada servidor: https://zennolab.github.io/zennoposter-mcp/install.html.

El modelo: tu propia instancia MCP con tu propia clave

El producto en sí mismo inicia servidores MCP internos para su chat de IA integrado — residen en la banda de puertos internos 6107–6113 (en ZennoDroid todo está desplazado por +10), reciben una clave de servicio de privilegios mínimos del host e ignoran el encabezado Authorization de las solicitudes entrantes. Esta es infraestructura interna: no se admite la conexión desde el exterior (los permisos allí los define la clave de servicio, no la tuya), y sus puertos no deben estar ocupados — un proceso externo en un puerto de esta banda impide que el servidor integrado se inicie (el producto registra un error, pero su pila de IA queda sin ese servidor).

Para tu propio cliente LLM, ejecutas una copia separada del servidor MCP desde el paquete público: escucha en la banda de puertos públicos 6207–6211 y se comunica con el mismo producto PublicApi (:5299 ProjectMaker / :5300 ZennoPoster), pero con tu ApiKey — con los ámbitos/nivel que elegiste al emitir la clave. Ambas copias se ejecutan en paralelo sin interferir entre sí.

En ZennoDroid, los dos servidores que atienden a ambos productos escuchan +10 más arriba — MCP.ProjectMaker en 6217, MCP.ZennoPoster en 6220 — el mismo desplazamiento que el producto aplica a su banda interna. De esta manera, una máquina con ambos productos instalados puede ejecutar ambos conjuntos a la vez. MCP.Android existe solo en ZennoDroid y mantiene 6211: nada en ZennoPoster lo ocupa.

Puertos predeterminados (configurados en el appsettings.json junto al exe):

Servidor	Puerto	Se comunica con	Clave en la configuración
`MCP.ProjectMaker`	6207	PM PublicApi `:5299`	`ProjectMaker:ApiKey`
`MCP.Instance` (Target=projectmaker)	6208	PM PublicApi `:5299`	`Instance:ApiKey`
`MCP.Instance` (Target=zennoposter)	6209 (convención, se establece explícitamente)	ZP PublicApi `:5300`	`Instance:ApiKey`
`MCP.ZennoPoster`	6210	ZP PublicApi `:5300`	`ZennoPoster:ApiKey`
`MCP.Android` (ZennoDroid, dispositivo editor)	6211	ZDroid PM PublicApi `:5309`	`Android:ApiKey`
`MCP.Android` (ZennoDroid, dispositivos de tareas)	6212 (convención, se establece explícitamente)	ZDroid ZP PublicApi `:5310`	`Android:ApiKey`

La API del producto a la que llaman esos servidores escucha en puertos diferentes en los dos productos:

Aplicación	ZennoPoster	ZennoDroid
ProjectMaker	5299	5309
ZennoPoster	5300	5310

Los valores predeterminados anteriores y los ejemplos siguientes son para ZennoPoster. En ZennoDroid, cada servidor necesita tanto su puerto de escucha como su BaseUrl establecidos explícitamente:

Servidor	Puerto	Se comunica con	Clave en la configuración
`MCP.ProjectMaker`	6217 (se establece explícitamente)	ZDroid PM PublicApi `:5309`	`ProjectMaker:ApiKey`
`MCP.ZennoPoster`	6220 (se establece explícitamente)	ZDroid ZP PublicApi `:5310`	`ZennoPoster:ApiKey`
`MCP.Android` (dispositivo editor)	6211	ZDroid PM PublicApi `:5309`	`Android:ApiKey`
`MCP.Android` (dispositivos de tareas)	6212 (se establece explícitamente)	ZDroid ZP PublicApi `:5310`	`Android:ApiKey`

Todo se puede sobrescribir mediante la configuración estándar de ASP.NET Core: el appsettings.json junto al exe, variables de entorno (ASPNETCORE_URLS, ProjectMaker__ApiKey, …) o argumentos de línea de comandos (--urls, --ProjectMaker:ApiKey=…, …) — los argumentos sobrescriben las variables de entorno, las variables de entorno sobrescriben appsettings.json.

1. Descarga el servidor que necesitas

En la página de releases, encuentra la última versión del servidor que necesitas (por prefijo de etiqueta), descarga su *-win-x64.zip y descomprímelo en cualquier carpeta. Cada archivo es un único .exe autónomo + appsettings.json; no se requiere un runtime adicional de .NET.

2. Emite una ApiKey

En ProjectMaker: Configuración → Claves API → Agregar — se abre el diálogo "Agregar clave API":

Establece un Label (un nombre de clave arbitrario, para distinguir las claves en la lista).
Elige el Max tier (el mínimo suficiente para tus tareas — T0 para solo lectura, mayor para operaciones de modificación).
Marca los Scopes que necesites (solo los *:read están marcados por defecto; agrega otros según sea necesario).
Confirma — la clave sin procesar se muestra una vez; cópiala a un lugar seguro de inmediato.

Más sobre ámbitos/niveles — security-model.md.

3. Ejecuta el servidor con tu clave

La clave se establece en la configuración propia del servidor MCP (no en los encabezados del cliente MCP — el servidor acepta conexiones solo desde loopback y no lee el encabezado Authorization de las solicitudes entrantes). La forma más sencilla es poner la clave en ApiKey en el appsettings.json junto al exe e iniciar sin argumentos; o pasarla mediante variables de entorno / argumentos:

# ProjectMaker (editor): 6207 -> :5299
.\ZennoLab.AI.MCP.ProjectMaker.exe --ProjectMaker:ApiKey=zp_xxx

# Instance for the editor (PM browser): 6208 -> :5299
.\ZennoLab.AI.MCP.Instance.exe --Instance:ApiKey=zp_xxx

# Instance for the runner — a SECOND copy of the same exe: the port and the Target/BaseUrl pair are set explicitly
.\ZennoLab.AI.MCP.Instance.exe --urls http://localhost:6209 `
  --Instance:Target=zennoposter --Instance:BaseUrl=http://localhost:5300/api/v1 `
  --Instance:ApiKey=zp_xxx

# ZennoPoster (runner tasks/sessions): 6210 -> :5300
.\ZennoLab.AI.MCP.ZennoPoster.exe --ZennoPoster:ApiKey=zp_xxx

# Android (the device attached to ProjectMaker): 6211 -> :5309
.\ZennoLab.AI.MCP.Android.exe --Android:ApiKey=zp_xxx

# Android for the runner — a SECOND copy of the same exe, for the devices of running tasks
.\ZennoLab.AI.MCP.Android.exe --urls http://localhost:6212 `
  --Android:BaseUrl=http://localhost:5310/api/v1 --Android:ApiKey=zp_xxx

MCP.Android se monta dos veces por la misma razón que MCP.Instance en ZennoPoster: el dominio de Android es atendido tanto por la PublicApi de ProjectMaker (el dispositivo que ves en el editor) como por la del ejecutor (los dispositivos que sus tareas están manejando). A diferencia de MCP.Instance, no tiene Target, por lo que las dos copias difieren solo por --urls y BaseUrl.

En ZennoDroid, los mismos dos ejecutables se inician en los puertos desplazados y se apuntan a la API de ZennoDroid:

# ProjectMaker on ZennoDroid: 6217 -> :5309
.\ZennoLab.AI.MCP.ProjectMaker.exe --urls http://localhost:6217 `
  --ProjectMaker:BaseUrl=http://localhost:5309/api/v1 --ProjectMaker:ApiKey=zp_xxx

# ZennoPoster tasks on ZennoDroid: 6220 -> :5310
.\ZennoLab.AI.MCP.ZennoPoster.exe --urls http://localhost:6220 `
  --ZennoPoster:BaseUrl=http://localhost:5310/api/v1 --ZennoPoster:ApiKey=zp_xxx

Nota importante sobre las dos copias de MCP.Instance: para el servidor Instance, Target (qué instrucciones sirve a la IA — sobre ProjectMaker o sobre ZennoPoster) y BaseUrl (a dónde van realmente las solicitudes HTTP) se configuran solo juntos, como un par, y no están vinculados en el código (Target=projectmaker → BaseUrl en la PM PublicApi :5299, Target=zennoposter → BaseUrl en la ZP PublicApi :5300). Al iniciar, el servidor realiza una verificación de mejor esfuerzo a través del /capabilities del host de destino y registra una advertencia en caso de discrepancia, pero si el host de destino no está disponible al iniciar, la verificación se omite silenciosamente — una discrepancia entonces no se detecta, y la IA recibe instrucciones sobre un host mientras las solicitudes van a otro.

4. Configura tu cliente LLM

Un fragmento de configuración listo para usar (el formato coincide con el .mcp.json de Claude Code; usa el equivalente para tu cliente MCP si es necesario):

{
  "servers": {
    "projectmaker": {
      "type": "http",
      "url": "http://localhost:6207"
    },
    "instance-pm": {
      "type": "http",
      "url": "http://localhost:6208"
    },
    "instance-zp": {
      "type": "http",
      "url": "http://localhost:6209"
    },
    "zennoposter": {
      "type": "http",
      "url": "http://localhost:6210"
    }
  }
}

En ZennoDroid, las entradas son estas — nombres diferentes, para que ambos productos se puedan configurar en un solo cliente, y sin montaje de instance-*, que ZennoDroid no tiene:

{
  "servers": {
    "projectmaker-droid": {
      "type": "http",
      "url": "http://localhost:6217"
    },
    "zennodroid": {
      "type": "http",
      "url": "http://localhost:6220"
    },
    "android-pm": {
      "type": "http",
      "url": "http://localhost:6211"
    },
    "android-zd": {
      "type": "http",
      "url": "http://localhost:6212"
    }
  }
}

No se necesita autorización en esta etapa: los servidores MCP escuchan solo en loopback, y los permisos los define la clave con la que se inició el propio servidor (paso 3).

5. Verifica la conexión

Con cualquier cliente MCP (o HTTP simple), llama a un método seguro de solo lectura y asegúrate de que responda 200 OK con los datos esperados — por ejemplo, get_product_version/ping en el servidor que necesites. Si la clave no es válida o carece de un ámbito/nivel, el servidor devuelve un error estructurado (401 unauthorized / 403 forbidden con campos required/current), no un fallo silencioso.

Cambio de puertos

Cada servidor tiene dos puertos: el que usa para escuchar a tu cliente LLM y el puerto de la API del producto al que llama.

Puerto de escucha. Cualquiera de los tres, los argumentos ganan sobre el entorno, el entorno sobre el archivo:

.\ZennoLab.AI.MCP.ProjectMaker.exe --urls http://localhost:7207

$env:ASPNETCORE_URLS = "http://localhost:7207"
.\ZennoLab.AI.MCP.ProjectMaker.exe

o "Urls": "http://localhost:7207" en el appsettings.json junto al exe. Después de mover un puerto de escucha, actualiza la URL correspondiente en la configuración del cliente del paso 4.

Mantente fuera de 6107–6113 (6117–6123 en ZennoDroid): esos pertenecen a los servidores integrados del producto, y un proceso externo en uno de ellos impide que el servidor integrado se inicie.

Puerto de la API del producto. Establece el BaseUrl de la sección propia de ese servidor — esto es lo que cambias en ZennoDroid:

# ProjectMaker API on 5309 instead of 5299
.\ZennoLab.AI.MCP.ProjectMaker.exe --ProjectMaker:BaseUrl=http://localhost:5309/api/v1 --ProjectMaker:ApiKey=zp_xxx

# ZennoPoster API on 5310 instead of 5300
.\ZennoLab.AI.MCP.ZennoPoster.exe --ZennoPoster:BaseUrl=http://localhost:5310/api/v1 --ZennoPoster:ApiKey=zp_xxx

La sección lleva el nombre del servidor: ProjectMaker, Instance, ZennoPoster, Android. Las versiones hasta 0.3.0 de MCP.ProjectMaker y MCP.ZennoPoster usaban NeuroBot y ZennoPosterApi; esos nombres aún funcionan en versiones posteriores y el servidor registra una advertencia al iniciar.

Licencia

Los archivos de este repositorio (documentación y especificación OpenAPI) están licenciados bajo la MIT License. Los binarios del servidor MCP en la página de Releases son propietarios; sus términos están en TERMS.md.