Servidor MCP de ProductPlan

Habla con tus hojas de ruta usando IA. Haz preguntas, crea ideas, verifica el progreso de los OKR y gestiona lanzamientos a través de una conversación natural con Claude, Cursor u otros asistentes de IA.

¿Qué puedes hacer con esto?

En lugar de hacer clic en la interfaz de ProductPlan, simplemente pregunta:

"¿Qué hay en nuestra hoja de ruta del primer trimestre?"

"Muéstrame todos los objetivos que están retrasados"

"Crea una nueva idea para mejoras en la aplicación móvil"

"¿Qué lanzamientos se acercan este mes?"

"Enumera todas las ideas etiquetadas como 'customer-request'"

La IA obtiene tus datos reales de ProductPlan y responde en segundos.

¿Para quién es esto?

• Gerentes de producto que desean un acceso más rápido a los datos de la hoja de ruta

• Líderes de equipo que necesitan actualizaciones de estado rápidas sin cambiar de contexto

• Cualquier persona que utilice asistentes de IA (Claude, Cursor, etc.) que desee integrar ProductPlan en su flujo de trabajo

No se requiere programación. Copiarás un archivo y pegarás algunas configuraciones.

Inicio rápido (5 minutos)

Paso 1: Obtén tu token de API de ProductPlan

1. Inicia sesión en ProductPlan

2. Ve a Settings → API (o visita este enlace directamente)

3. Copia tu token de API

Paso 2: Descarga la aplicación

Ve a la página de lanzamientos y descarga el archivo correcto para tu computadora:

En Mac/Linux, abre la Terminal y ejecuta estos dos comandos (reemplaza el nombre del archivo con el que descargaste):

chmod +x ~/Downloads/productplan-darwin-arm64
sudo mv ~/Downloads/productplan-darwin-arm64 /usr/local/bin/productplan

Se te pedirá tu contraseña. Esto es normal.

En Windows:

1. Crea una carpeta para el binario (si no existe):

   mkdir C:\Tools

2. Mueve el .exe descargado a esa carpeta y cámbiale el nombre:

   move %USERPROFILE%\Downloads\productplan-windows-amd64.exe C:\Tools\productplan.exe

3. Usa la ruta completa C:\Tools\productplan.exe en la configuración de tu asistente de IA (se muestra en el Paso 3)

Nota: Puedes omitir añadirlo a PATH. Simplemente usa la ruta completa del archivo en tu configuración.

Paso 3: Conéctate a tu asistente de IA

Elige la herramienta que utilizas:

1. Encuentra tu archivo de configuración:

   • Mac: ~/Library/Application Support/Claude/claude_desktop_config.json

   • Windows: %APPDATA%\Claude\claude_desktop_config.json

2. Ábrelo en cualquier editor de texto y añade esto (reemplaza your-token con tu token de API real):

Mac/Linux:

{
  "mcpServers": {
    "productplan": {
      "command": "/usr/local/bin/productplan",
      "env": {
        "PRODUCTPLAN_API_TOKEN": "your-token"
      }
    }
  }
}

Windows:

{
  "mcpServers": {
    "productplan": {
      "command": "C:\\Tools\\productplan.exe",
      "env": {
        "PRODUCTPLAN_API_TOKEN": "your-token"
      }
    }
  }
}

3. Reinicia Claude Desktop

Añade a tu archivo de configuración:

• Mac/Linux: ~/.claude.json

• Windows: %USERPROFILE%\.claude.json

Mac/Linux:

{
  "mcpServers": {
    "productplan": {
      "command": "/usr/local/bin/productplan",
      "env": {
        "PRODUCTPLAN_API_TOKEN": "your-token"
      }
    }
  }
}

Windows:

{
  "mcpServers": {
    "productplan": {
      "command": "C:\\Tools\\productplan.exe",
      "env": {
        "PRODUCTPLAN_API_TOKEN": "your-token"
      }
    }
  }
}

1. Abre Cursor

2. Ve a Settings → MCP Servers

3. Añade esta configuración:

Mac/Linux:

{
  "productplan": {
    "command": "/usr/local/bin/productplan",
    "env": {
      "PRODUCTPLAN_API_TOKEN": "your-token"
    }
  }
}

Windows:

{
  "productplan": {
    "command": "C:\\Tools\\productplan.exe",
    "env": {
      "PRODUCTPLAN_API_TOKEN": "your-token"
    }
  }
}

Usuarios de Windows: Usa barras invertidas dobles (\\) en la ruta. Esto es necesario porque la barra invertida es un carácter de escape en JSON.

1. Instala la extensión Cline

2. Abre la configuración de VS Code (JSON) y añade:

Mac/Linux:

{
  "cline.mcpServers": {
    "productplan": {
      "command": "/usr/local/bin/productplan",
      "env": {
        "PRODUCTPLAN_API_TOKEN": "your-token"
      }
    }
  }
}

Windows:

{
  "cline.mcpServers": {
    "productplan": {
      "command": "C:\\Tools\\productplan.exe",
      "env": {
        "PRODUCTPLAN_API_TOKEN": "your-token"
      }
    }
  }
}

1. Instala la extensión Continue

2. Añade a tu archivo de configuración:

   • Mac/Linux: ~/.continue/config.json

   • Windows: %USERPROFILE%\.continue\config.json

Mac/Linux:

{
  "mcpServers": [
    {
      "name": "productplan",
      "command": "/usr/local/bin/productplan",
      "env": {
        "PRODUCTPLAN_API_TOKEN": "your-token"
      }
    }
  ]
}

Windows:

{
  "mcpServers": [
    {
      "name": "productplan",
      "command": "C:\\Tools\\productplan.exe",
      "env": {
        "PRODUCTPLAN_API_TOKEN": "your-token"
      }
    }
  ]
}

1. Establece la variable de entorno en tu instancia de n8n:

   N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true

2. Añade un nodo MCP Client a tu flujo de trabajo

3. Configura:

   • Command:

     • Mac/Linux: /usr/local/bin/productplan

     • Windows: C:\Tools\productplan.exe

   • Environment Variables: PRODUCTPLAN_API_TOKEN=your-token

4. Conéctate a un nodo AI Agent

Ejemplo de flujo de trabajo: Slack Trigger → AI Agent (con MCP Client) → Slack Response

Paso 4: Empieza a hacer preguntas

Abre tu asistente de IA y prueba:

• "Enumera mis hojas de ruta de ProductPlan"

• "¿Qué barras hay en la hoja de ruta [nombre]?"

• "Muéstrame nuestros OKR"

• "¿Qué ideas están en descubrimiento?"

Casos de uso en el mundo real

Preparación para la reunión diaria (standup)

"Resume qué cambió en nuestra hoja de ruta de producto la última semana"

Actualizaciones para las partes interesadas

"Enumera todos los objetivos del primer trimestre y su progreso"

Clasificación de ideas

"Muéstrame todas las ideas etiquetadas como 'enterprise' que no tienen una prioridad establecida"

Coordinación de lanzamientos

"¿Qué tareas siguen incompletas para el lanzamiento de enero?"

Búsquedas rápidas

"¿Cuándo está programado el inicio de la barra 'Mobile App v2'?"

¿A qué datos de ProductPlan puedes acceder?

Cómo funciona

┌─────────────────┐      spawns       ┌─────────────────┐      API calls     ┌─────────────────┐
│   AI Assistant  │ ───────────────── │   MCP Server    │ ─────────────────▶ │   ProductPlan   │
│ (Claude, Cursor)│ ◀───────────────▶ │   (this binary) │ ◀───────────────── │      API        │
└─────────────────┘   stdin/stdout    └─────────────────┘     JSON data      └─────────────────┘
      your computer                        your computer                         cloud

¿Por qué esto necesita ejecutarse en tu computadora?

MCP (Model Context Protocol) funciona a través de un modelo de subprocesos. Tu asistente de IA no se conecta a un servidor remoto; genera el binario como un proceso local y se comunica a través de stdin/stdout. Esta arquitectura significa que:

1. El binario debe existir localmente porque tu asistente de IA lo ejecuta como un proceso hijo

2. Tu token de API permanece en tu máquina, nunca pasando por servidores de terceros

3. Comunicación síncrona en tiempo real sin latencia de red entre la IA y el servidor MCP

4. Funciona sin conexión para datos en caché (aunque las llamadas a la API de ProductPlan aún necesitan internet)

Cuando preguntas "¿Qué hay en nuestra hoja de ruta del primer trimestre?", esto es lo que sucede:

1. Tu asistente de IA reconoce que necesita datos de ProductPlan

2. Envía una solicitud estructurada al proceso del servidor MCP

3. El binario traduce esto en llamadas a la API de ProductPlan

4. ProductPlan devuelve datos JSON

5. El binario formatea y devuelve los resultados a tu IA

6. Tu IA presenta la respuesta en lenguaje natural

Habilidades de agente

Guías de flujo de trabajo preconstruidas que enseñan a los asistentes de IA cómo utilizar las herramientas de ProductPlan de manera efectiva. Cada habilidad se dirige a una persona específica con flujos de trabajo personalizados.

Principios compartidos

Todas las habilidades siguen estas convenciones de salida:

• Sin JSON sin procesar - Formatea las respuestas como texto legible y tablas

• Fechas legibles por humanos - Usa "Marzo 2025" o "Q1 2025", no "2025-03-15"

• Resumir listas grandes - No abrumes con 50 elementos; ofrece expandir

Variaciones específicas de persona:

• PM incluye bar_id para acciones de seguimiento

• Liderazgo comienza con un resumen ejecutivo, oculta detalles de implementación

• Cara al cliente omite IDs internos, nombres de carriles y OKR por completo

Para usar una habilidad, copia el archivo SKILL.md a tu directorio de habilidades de Claude Code:

# Copy a skill (example: PM skill)
cp skills/productplan-pm/SKILL.md ~/.claude/skills/productplan-pm.md

O referencia las habilidades directamente en tus prompts:

"Usa el flujo de trabajo productplan-pm para mostrarme nuestra hoja de ruta del primer trimestre"

Solución de problemas

"Command not found" o "spawn ENOENT"

Tu asistente de IA no puede encontrar el binario. Esto significa:

• Mac/Linux: El archivo no está en /usr/local/bin/productplan, o olvidaste ejecutar chmod +x

• Windows: La ruta en tu configuración no coincide con donde guardaste el .exe

Solución: Verifica que el binario exista en la ruta de tu configuración. Ejecuta ls -la /usr/local/bin/productplan (Mac/Linux) o verifica si C:\Tools\productplan.exe existe (Windows).

Problemas de ruta en Windows

Errores comunes en Windows:

Windows usa barras invertidas (\) para las rutas, pero JSON trata la barra invertida como un carácter de escape. Debes duplicarlas (\\) en tu archivo de configuración.

"Invalid API token"

Verifica dos veces tu token en ProductPlan Settings → API. Los tokens pueden caducar o ser regenerados. Asegúrate de haber copiado el token completo sin espacios adicionales.

"No roadmaps found"

Tu token de API solo accede a los datos que tienes permiso para ver en ProductPlan. Verifica que tu cuenta tenga acceso a las hojas de ruta que estás buscando.

El asistente de IA no ve las herramientas de ProductPlan

Los servidores MCP se cargan cuando se inicia tu asistente de IA, no cuando cambian las configuraciones. Después de editar tu archivo de configuración, cierra completamente y reinicia la aplicación. En Mac, usa Cmd+Q (no solo cerrar la ventana).

"Permission denied" en Mac/Linux

El binario necesita permiso de ejecución. Ejecuta:

chmod +x /usr/local/bin/productplan

Línea de comandos (opcional)

También puedes usar esta herramienta directamente en la Terminal sin un asistente de IA:

# First, set your token
export PRODUCTPLAN_API_TOKEN="your-token"

# Then run commands
productplan status           # Check connection
productplan roadmaps         # List all roadmaps
productplan bars 12345       # List bars in roadmap #12345
productplan objectives       # List all OKRs
productplan ideas            # List all ideas
productplan opportunities    # List all opportunities
productplan launches         # List all launches

Información de fondo

¿Qué es MCP?

Model Context Protocol (MCP) es un estándar abierto que permite a los asistentes de IA conectarse a herramientas externas. Anthropic lo creó; otros proveedores de IA lo están adoptando. Este servidor implementa MCP para que tu asistente de IA pueda leer y escribir datos de ProductPlan.

¿Qué es ProductPlan?

ProductPlan es un software de hoja de ruta utilizado por más de 4,000 equipos de producto. Maneja hojas de ruta, OKR, descubrimiento de ideas y coordinación de lanzamientos.

Para desarrolladores

productplan-mcp-server/
├── cmd/productplan/main.go      # Entry point (~100 lines)
├── internal/
│   ├── api/                     # ProductPlan API client
│   │   ├── client.go            # HTTP client with caching, retry, rate limiting
│   │   ├── endpoints.go         # 40+ API endpoint methods
│   │   └── formatters.go        # Response enrichment for AI
│   ├── mcp/                     # MCP protocol implementation
│   │   ├── server.go            # JSON-RPC server, stdio I/O
│   │   ├── handler.go           # Tool dispatch via registry
│   │   └── types.go             # Protocol types
│   ├── tools/                   # Tool definitions and handlers
│   │   ├── registry.go          # Tool registration and dispatch
│   │   └── types.go             # Typed argument structs for handlers
│   ├── cli/                     # CLI commands (status, roadmaps, etc.)
│   │   └── cli.go
│   └── logging/                 # Structured JSON logging
│       └── logger.go
├── pkg/productplan/             # Reusable utilities
│   ├── cache.go                 # LRU cache with TTL
│   ├── retry.go                 # Exponential backoff with jitter
│   ├── ratelimit.go             # Adaptive rate limiting
│   ├── registry.go              # ToolBuilder for schema generation
│   ├── requestid.go             # Request tracing
│   └── errors.go                # Error suggestions
└── evals/                       # LLM evaluation test suite
    ├── tool_selection.json
    ├── confusion_pairs.json
    └── argument_correctness.json