PR
Developer Tools

Productboard API MCP Server Integration for Agentic Workflows

Integrate Productboard API with agentic workflows using an MCP server to automate feature planning, feedback loops, and decision-making.

View on GitHub
Quick Install
npx -y @kenjihikmatullah/productboard-mcp

Overview

This repository implements an MCP (Model Context Protocol) server that connects Productboard’s API to agentic workflows. The server exposes a small, well-documented set of HTTP tool endpoints that LLM agents or automation systems can call to read feedback, create and update features, query roadmaps, and link feedback to decisions. By presenting Productboard actions as tools over MCP, agents can participate directly in planning, triage, and decision-making loops.

Using an MCP server for Productboard is useful for automating repetitive product-management operations (triage, prioritization, status updates) and for closing feedback loops more quickly. Agents can enrich workflows with programmatic rules or LLM intelligence while the MCP server handles authentication, API details, rate limits, and data shaping so the agent sees a simple, consistent interface.

Features

  • Exposes Productboard operations as MCP-style tools (create_feature, list_feedback, link_feedback, update_feature, query_roadmap, etc.)
  • Authentication and credential management for Productboard API tokens
  • Request/response shaping to present concise tool inputs/outputs for LLM agents
  • Webhook or polling support for ingesting new feedback events
  • Lightweight HTTP server with configurable port and CORS
  • Docker-ready image for easy deployment
  • Logging and basic error handling for observability

Installation / Configuration

Clone the repository and run locally or in Docker. The repo includes an MCP server implementation and a small CLI to run it.

  1. Clone and run locally (Node.js example)
git clone https://github.com/kenjihikmatullah/productboard-mcp.git
cd productboard-mcp

# Install (Node.js)
npm ci

# Create a .env file (see below)
cp .env.example .env

# Start
npm start
  1. Run with Docker
# Build
docker build -t productboard-mcp .

# Run (replace token with your Productboard API key)
docker run -d \
  -e PRODUCTBOARD_API_TOKEN="prod_XXXX" \
  -e MCP_PORT=3333 \
  -p 3333:3333 \
  --name productboard-mcp \
  productboard-mcp
  1. Minimal environment variables (example .env)
PRODUCTBOARD_API_TOKEN=prod_XXXXXXXXXXXXXXXX
MCP_PORT=3333
ALLOWED_ORIGINS=http://localhost:3000
LOG_LEVEL=info
PRODUCTBOARD_API_BASE=https://api.productboard.com

Note: The server expects a Productboard API token with appropriate scopes to read feedback and create/modify features. Configure ALLOWED_ORIGINS for browser-based agent UIs.

Available Tools / Resources

The MCP server exposes HTTP endpoints that map to Productboard actions. Endpoints are designed to be called by agents; the exact path can be /mcp/tools/{toolName} or similar (see server OpenAPI if provided).

Key tools (name | description | input highlights):

  • list_feedback — Query feedback items (filters: since, score, source)
  • create_feature — Create a new feature in Productboard (title, description, priority)
  • update_feature — Update feature fields or status (feature_id, fields)
  • link_feedback — Attach feedback items to a feature (feature_id, feedback_ids)
  • query_roadmap — Return roadmap items or releases (timebox, release_id)
  • search_insights — Full-text search across feedback and notes

Example tool call (curl)

curl -X POST "http://localhost:3333/mcp/tools/create_feature" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Automated import of CSV feedback",
    "description": "Allow importing bulk feedback from CSV with source metadata",
    "priority": "high",
    "metadata": {"created_by": "agentic-triage"}
  }'

Example Python call

import requests
resp = requests.post(
    "http://localhost:3333/mcp/tools/list_feedback",
    json={"since": "2026-01-01T00:00:00Z", "limit": 50}
)
print(resp.json())

If the repo includes an OpenAPI spec, point your client to /openapi.json to inspect available endpoints and input/output schemas.

Use Cases

  • Automated backlog triage

    • An agent monitors new feedback and applies rules or an LLM to decide whether to create a new feature, link to an existing feature, or tag feedback for follow-up. The agent calls list_feedback, evaluate, then create_feature or link_feedback as needed.

  • Feedback-driven prioritization

    • Periodic agent workflows aggregate recent feedback (list_feedback / search_insights), compute priority scores, and update feature priority fields using update_feature. This produces a continuously prioritized backlog.

  • Auto-generate feature specs

    • When an agent detects a recurring problem in feedback, it can create a draft feature with create_feature and populate the description with a structured spec (user problem, acceptance criteria, impact) drafted by an LLM.

  • Decision auditing and traceability

    • Agents can attach decision notes and link feedback to features so you can later trace why a feature was added or prioritized. Use link_feedback and update_feature to maintain a clear audit trail.

  • Roadmap sync and notifications

    • Query roadmap (query_roadmap) and notify stakeholders (via webhooks or downstream systems) when features move to releases or change status.

Next steps

  • Inspect the repo’s OpenAPI or README for exact endpoint paths and input schemas.
  • Add the Productboard API token as an environment variable
Tags:developer-tools