mk-plan-master
The mk-plan-master server provides an AI-driven planning and prioritization toolkit that bridges idea capture and formal specification. Here's what you can do:
Manage Initiatives: List, fetch, and add product initiatives from local Markdown files, Linear, JIRA, or Notion. Auto-summarize ideas from chat, WebFetch, or call notes with generated IDs.
Analyze & Score: Run a structured senior-PM analysis (target users, competition, risks, MVP scope) before scoring. Apply RICE or Impact-Effort to individual initiatives or the full backlog, with auto-tier classification (P0–P3) and archived snapshots.
Plan Roadmaps: Generate quarterly roadmaps by packing ranked initiatives into an engineering capacity envelope (with configurable buffer), outputting commitments, stretch goals, and deferred items. Analyze roadmap balance across feature, tech-debt, and strategic buckets.
Generate Spec Drafts: Produce formatted Markdown spec drafts (default, lite, or detailed templates) ready for direct ingestion by
mk-spec-master.Manage Planning Knowledge: Initialize and read a
plan-knowledge.mdfile containing scoring frameworks (RICE, WSJF, Impact-Effort), OKR mappings, personas, and a domain glossary to keep all scoring decisions consistently framed.Monitor Planning Quality: Track backlog trends over 7- and 30-day snapshots, detect chronic issues (ghost initiatives, score whiplash, orphan OKRs), and analyze tool usage telemetry (call frequency, error rates, latency) for self-improvement.
Provides tools to list, fetch, and manage initiatives from Jira, serving as a source for idea triage and planning.
Provides tools to list, fetch, and manage initiatives from Linear, serving as a source for idea triage and planning.
Provides tools to manage initiatives as local Markdown files, enabling idea capture and planning from a local project root.
Provides tools to list, fetch, and manage initiatives from Notion, serving as a source for idea triage and planning.
Idea triage + RICE scoring + quarterly roadmap + spec-draft bridge — over MCP. Reads from Linear / JIRA / Notion / Markdown, hands the generated spec draft directly to
mk-spec-master.parse_spec, and remembers every decision so the same idea never bounces back unexplained.
🟢 Alpha — v0.1. 15 tools + 4 adapters + 77 tests passing. Full design in
docs/prd.md. Walkthrough using a real dogfood case indocs/walkthrough.md.
Why this exists
With mk-plan-master shipped, the AI-driven dev pipeline now looks like this:
Idea → Plan → Spec → Code → Test → Coverage → Coach
mk-plan mk-spec your IDE mk-qa mk-spec bothUntil v0.1 the upstream slot was a ??? — mk-spec-master could parse a spec, mk-qa-master could run tests, but nobody had built the piece that turns a pile of 30–200 raw ideas (chat snippets, customer calls, URLs, gut hunches) into a prioritized, RICE-scored backlog and emits a spec draft that drops straight into mk-spec-master.parse_spec(raw_text=...) — no manual reformatting, no copy-paste fragility.
mk-plan-master is that piece. The mk-* family is now whole:
mk-plan-master— ideas in, prioritized plans + spec drafts out (this repo)mk-spec-master— specs in, scenarios out, coverage matrixmk-qa-master— scenarios in, runnable tests out (pytest / Jest / Cypress / Go test / Maestro)
It's also the planning MCP that measures its own decision quality over time — history snapshots, decision signatures (ghost initiatives / score whiplash / orphan OKRs), and tool-usage telemetry. The mk-spec-master v0.4 self-reinforcement layer, applied one step upstream.
Related MCP server: mk-spec-master
The family loop
┌─────────┐ ┌──────────┐ ┌─────────┐ ┌─────────┐ ┌──────────┐ ┌─────────┐
│ Idea │ ───> │ Plan │ ───> │ Spec │ ───> │ Code │ ───> │ Test │ ───> │ Coverage│
│ (chat, │ │ mk-plan- │ │ mk-spec-│ │ your IDE│ │ mk-qa- │ │ mk-spec-│
│ URL, │ │ master │ │ master │ │ (Claude │ │ master │ │ master │
│ call) │ │ │ │ │ │ Code / │ │ │ │ │
│ │ │ RICE + │ │ AC + │ │ Cursor /│ │ runnable │ │ matrix │
│ AI │ │ roadmap +│ │ scenarios│ │ Copilot)│ │ tests in │ │ + drift │
│ summary │ │ spec │ │ + drift │ │ writes │ │ pytest / │ │ + coach │
│ │ │ draft │ │ │ │ impl │ │ Jest / …│ │ │
└─────────┘ └──────────┘ └─────────┘ └─────────┘ └──────────┘ └─────────┘
▲ │ │ ▲ ▲ │
│ │ │ │ │ │
│ └──── spec_draft ──┘ │ │ │
│ │ │ │
│ red tests ──┘ │ │
│ │ │
└─────────────────── decision history / chronic patterns ───────────────────┴──────────────────┘Important. Code lives in your IDE, not in the family. Between spec and green tests, Claude Code / Cursor / Copilot writes the actual implementation. The MCP family wraps the rails — planning, spec, test, coverage, coach — and deliberately leaves the code-writing layer to whatever AI-pair-programming tool you already use. Tests generated by mk-qa-master are a runnable TODO list; the IDE loop flips them red → green.
Install
uvx mk-plan-master # or: pip install mk-plan-masterAdd to your MCP client config:
{
"mcpServers": {
"mk-plan-master": {
"command": "uvx",
"args": ["mk-plan-master"],
"env": {
"PLAN_SOURCE": "markdown_local",
"PLAN_PROJECT_ROOT": "/path/to/your/project"
}
}
}
}Works in Claude Desktop, Claude Code, Cursor, Codex CLI, Gemini CLI — any MCP client.
Claude Desktop config lives at:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.jsonLinux:
~/.config/Claude/claude_desktop_config.json
Then in your AI session:
"Use mk-plan-master to score every triage idea, pick the top one, run analyze_initiative on it, then generate a spec draft and hand it to mk-spec-master."
Tool surface (15 tools)
Grouped by role in the idea → plan → spec → memory loop.
Meta — orientation (1)
Tool | Purpose |
| Active adapter + all available + version. Call first so the AI knows whether to expect markdown / Linear / JIRA / Notion semantics |
Discovery — find and load ideas (2)
Tool | Purpose |
| Enumerate initiatives from the active source (filter by status / label / limit). For Linear: triage / backlog / unstarted. For JIRA: statusCategory='To Do'. For Notion: status in (Triage / Backlog / Idea) |
| Pull a single initiative by id. Returns |
Capture — chat / WebFetch handoff (1)
Tool | Purpose |
| Persist an idea you (the AI client) already gathered via WebFetch / chat / call notes into |
Analysis — the senior-PM SOP (1)
Tool | Purpose |
| Force a senior-PM analysis SOP before scoring. Returns a structured checklist (target users / competition / market signal / risks / MVP scope / out-of-scope / RICE rationale) the AI must fill in inline. Loads |
Scoring — prioritize the backlog (2)
Tool | Purpose |
| Score one initiative with RICE or Impact-Effort. Pass |
| Score the whole backlog and return the top-N descending. Pure arithmetic, deterministic rationale strings. Auto-archives a snapshot to |
Bridge — the family lock-in (1)
Tool | Purpose |
| The family-bridge tool. Produce a markdown spec draft shaped so |
Roadmap — quarterly planning (2)
Tool | Purpose |
| Pack the ranked backlog into a quarterly markdown roadmap, respecting an engineering capacity envelope (engineer-months × 4 person-weeks) minus a buffer (default 20%). Greedy score-per-effort packer. Output split into P0 commitments / P1 commitments / P2 stretch / Deferred / Capacity summary |
| Classify top-N initiatives into feature / tech_debt / strategic / unlabeled buckets, surface ratio + score-share + heuristic advisory. Label vocabularies configurable. Answers "is the roadmap balanced?" / "are we starving tech debt?" |
Knowledge — methodology layer (2)
Tool | Purpose |
| Create |
| Read |
Self-reinforcement — long-running view (3)
Tool | Purpose |
| Trend deltas (current vs ~7d / ~30d) for top-10 RICE-ranked snapshots. Surfaces churn + average score. "Are we improving?" / "Is the same idea always at the top?" |
| Chronic patterns: ghost initiatives (top-10 in >50% of snapshots but never spec_generated), score whiplash (RICE swings >50% between snapshots → bad data quality), orphan OKRs (in index but zero initiatives in current top-10). "Which ideas keep getting punted?" |
| Aggregate |
Adapter status
| Source | Status | Auth |
| Local | Shipped in v0.1.0 | none |
| Linear API (GraphQL), filtered to triage / backlog / unstarted state types | Shipped in v0.1.0 |
|
| JIRA Cloud (REST v3, ADF → markdown), filtered to | Shipped in v0.1.0 |
|
| Notion databases (REST v1, blocks → markdown), filtered to Status in (Triage / Backlog / Idea) | Shipped in v0.1.0 |
|
Why analyze_initiative exists — a real case study
This is the differentiator. AI clients, by default, shortcut into a shallow read of any idea handed to them. They infer Reach / Impact / Confidence / Effort from a 2-paragraph blurb and produce a confident-looking RICE score that's mostly noise. The numbers below are from the actual dogfood corpus in mk-plan-test/ — same URL, same idea, two passes.
Pass 1 — without analyze_initiative (the AI just reads the URL and guesses):
IDEA-001 · 一鍵式 IP 授權平台(AI + 區塊鏈)
reach 500
impact 2
confidence 0.5
effort 12 person-weeks
out_of_scope [] (none)
RICE (500 × 2 × 0.5) / 12 = 41.7 → P0A confident P0. Looks like a no-brainer "ship it next quarter."
Pass 2 — with analyze_initiative (the AI is forced through the senior-PM SOP first):
IDEA-002 · RightClick — 一鍵式 IP 授權平台(AI + 區塊鏈)
reach 250 ← scoped to "active users per quarter
in initial regions (Singapore + US-west
social), not raw addressable market"
impact 2 ← same
confidence 0.4 ← dropped: logo wall is unverifiable,
AI-contract legal status untested,
two-sided cold-start unproven, no GMV
effort 18 person-weeks ← raised: wallet 3w + AI templates 4w
+ contracts/NFT 3w + marketplace 3w
+ lawyer review + security 3w
+ backoffice/observability 2w
out_of_scope 8 explicit items ← fiat rails, cross-chain bridging,
derivative auto-royalties (v2),
multi-jurisdiction custom legal,
DRM, PRO-style collective rights,
video/animation, enterprise SSO
RICE (250 × 2 × 0.4) / 18 = 11.1 → P1The delta — same URL, same idea, an order of magnitude more honest:
Field | Pass 1 (junior PM) | Pass 2 (senior PM SOP) | Delta |
reach | 500 | 250 | scoped down |
confidence | 0.5 | 0.4 | dropped — logo washing risk, AI-contract legal risk surfaced |
effort | 12 pw | 18 pw | +6 pw for lawyer review + security |
out_of_scope | 0 items | 8 items | explicit MVP fence |
RICE | 41.7 | 11.1 | 3.8× drop |
tier | P0 | P1 | one tier down |
P0 → P1 is the difference between "ship next quarter" and "validate first." analyze_initiative is the SOP that gets you there without needing a senior PM in the room. Same idea, same source URL — different rigor.
Both initiatives are in mk-plan-test/initiatives/ verbatim. Both spec drafts are in mk-plan-test/specs/. The full decision trail is in .mk-plan-master/index.json — every scored and spec_generated event with timestamps. Walkthrough with prompts + tool chains in docs/walkthrough.md.
4 prompting workflows
Four natural-language prompts cover ~90% of real use. Each is one sentence to your AI client; the tools chain automatically.
1. Lock one idea — URL → spec_draft
"I read https://rightclickip.xyz/ — capture it as an initiative, run analyze_initiative on it, score it, and produce a detailed spec draft I can hand to mk-spec-master."
Chains: add_initiative (from your chat summary, family does NOT crawl) → analyze_initiative → add_initiative(overwrite=true) (with the enriched body) → score_initiative → generate_spec_draft(template="detailed") → mk-spec-master.parse_spec(raw_text=...).
2. Weekly backlog re-rank — trend over time
"Every Monday, rank my Linear triage backlog with RICE and show me the trend vs last week and last month."
Chains: rank_backlog(method="rice", limit=10) → get_planning_history(window_days=30). The first call auto-archives the snapshot; the second reads them all and computes deltas.
3. Senior-PM SOP on demand
"Apply the senior-PM analysis SOP to IDEA-014 — I want target users, competition, market signal, risks, MVP scope, out-of-scope, and RICE rationale before I score it."
Chains: get_plan_context (loads methodology + glossary) → fetch_initiative("IDEA-014") → analyze_initiative("IDEA-014", framework="default") → AI fills checklist in response → add_initiative(overwrite=true) → score_initiative.
4. Quarterly roadmap from Notion triage
"Pull every Notion idea in the Triage view, rank them with RICE, then pack a Q3 2026 roadmap assuming 4 engineers and 20% buffer. Tell me if the feature/tech-debt/strategic mix looks healthy."
Chains: list_initiatives(status="triage") → rank_backlog → generate_roadmap(capacity_engineer_months=12, period="Q3 2026", buffer_pct=20) → analyze_roadmap_balance.
Self-reinforcement layer
get_planning_history + get_decision_signature + get_telemetry are the trio that makes mk-plan-master measure its own decision quality over time. The mk-spec-master v0.4 pattern, applied one step upstream.
Layer | Question it answers | Storage |
History | "Are we improving? Is the same idea always at the top?" |
|
Decision signature | "Which ideas keep getting punted (ghost)? Which scores swing wildly (whiplash)? Which OKRs have zero execution (orphan)?" | Computed from history + |
Telemetry | "What's the AI actually using? Which tools are slow? Which are dead surface?" |
|
Same shape as mk-spec-master's get_spec_history / get_drift_signature / get_telemetry, so if you already trust that pattern you know the layout.
The decisions[] audit trail on every initiative ("why did we deprioritize this last quarter?") is what kills the bouncing back problem. No more "didn't we discuss this in March?" — March's RICE breakdown is in the index with its confidence and effort values.
Why this is missing from the ecosystem
Tool | Lock-in | What we do differently |
Productboard | $20-50/user/mo, walled garden | MCP-native: lives where the AI lives. Read existing Linear / JIRA / Notion, don't import to a new tool |
Aha! | $59-149/user/mo, enterprise | Open-source baseline, SMB / indie / AI-native segment |
Linear / JIRA | Backlog UI, no triage framework, no plan→spec bridge | We add the scoring + roadmap + spec-bridge layers on top of what you already have |
Cursor / Claude "ask AI to plan" | Free-form chat, no persistence | Structured outputs, JSON index, traceable decisions, snapshot history |
AWS Kiro plan phase | AWS IDE only, proprietary | MCP-native, multi-client |
GitHub Spec Kit | Spec-first, doesn't reach upstream into idea triage | We're the missing pre-spec layer; complementary |
See docs/prd.md §4 for the full positioning.
Status
Milestone | Scope | Status |
v0.1 (4 adapters, 15 tools, RICE + Impact-Effort, generate_spec_draft, plan-knowledge, self-reinforcement) | This release | Shipped |
v0.2 (Productboard adapter, | +1 week | Planned |
v0.3 (Intercom / Zendesk adapters, | +2 weeks | Planned |
v1.0 (production-ready, docs, integration recipes, blog series) | Q3 2026 | Planned |
77 tests passing on Python 3.10 / 3.11 / 3.12 / 3.13.
Family
mk-spec-master— AI 規格大師. Spec → scenarios → coverage matrix.generate_spec_draftoutput is shaped to drop into itsparse_spec(raw_text=...)verbatim.mk-qa-master— AI 測試大師. Scenarios → runnable tests in pytest / Jest / Cypress / Go test / Maestro.
The family loop: mk-plan-master → mk-spec-master → your IDE → mk-qa-master → back into mk-spec-master coverage.
License
MIT © 2026 Jack Kao — see LICENSE.
Plain-English version: personal use, commercial use, modification, redistribution — all allowed. The only requirement is that you keep the copyright and license notice in your copy. No warranty: if it breaks in production, you can't come after the author.
Built by Jack Kao . Part of the mk-* family: mk-qa-master + mk-spec-master + mk-plan-master.
If this saved you time, a coffee goes a long way.
Available Tools
15 toolsadd_initiativeA
Write a new markdown_local initiative into PLAN_PROJECT_ROOT/initiatives/.md. Use this to capture an idea you (the AI client) already gathered via WebFetch / chat summary / customer-call notes — plan-master deliberately does NOT crawl URLs; you summarize, this tool persists. Only works when PLAN_SOURCE=markdown_local; for Linear / JIRA / Notion, create the issue in that platform instead. If id is omitted, auto-generates IDEA-NNN. Returns {id, written_to, source, overwritten, next_step_hint}. Typical chain: add_initiative -> score_initiative -> generate_spec_draft -> mk-spec-master.parse_spec.
Inputs: title (required), body, id, status, +9 more.
analyze_initiativeA
Force a senior-PM analysis SOP on one initiative BEFORE scoring. Returns the initiative body + a structured checklist (target users / competition / market signal / risks / MVP scope / out-of-scope / RICE rationale) the AI client must fill in inline as its response. Loads plan-knowledge.md context if present. The tool does NOT call an LLM — it scaffolds the prompt so the AI doesn't shortcut into a shallow read. Use this WHENEVER an idea originates from chat / WebFetch and lacks a thorough product analysis. After filling the checklist, call add_initiative(overwrite=true) with the enriched body, then score_initiative. Framework options: 'default' (7 sections), 'lite' (4 sections), 'lean_canvas' (9 blocks). Returns {initiative, framework, methodology_context, analysis_checklist, instructions, next_step_hint}.
Inputs: initiative_id (required), framework.
analyze_roadmap_balanceA
Classify the top-N ranked initiatives into feature / tech_debt / strategic / unlabeled buckets by label, then surface ratio + score-share + a terse heuristic advisory. Use when a user asks 'is the roadmap balanced' / 'are we starving tech debt' / 'do we have any strategic bets'. Label vocabularies are configurable: feature_labels (default ['feature', 'product']), tech_debt_labels (default ['tech-debt', 'refactor', 'infra']), strategic_labels (default ['strategic', 'bet', 'moonshot']). Returns {method, totals, ratio_pct, score_share_pct, advisory}.
Inputs: method, limit, feature_labels, tech_debt_labels, +1 more.
fetch_initiativeA
Pull a single initiative by id from the active source. Returns the full Initiative record {id, source, title, body, url, status, labels, raw_metadata}. raw_metadata holds scoring inputs (reach / impact / confidence / effort / okr) plus any source-specific fields. Pair with score_initiative to get a RICE / Impact-Effort rank.
Inputs: initiative_id (required).
generate_roadmapA
Pack the ranked backlog into a quarterly roadmap markdown, respecting an engineering capacity envelope (in engineer-months × 4 person-weeks) minus a buffer (default 20%). Uses a greedy score-per-effort packer — items with the highest RICE-per-pw ratio land first. Output is split into P0 commitments / P1 commitments / P2 stretch / Deferred / Capacity summary. Required: capacity_engineer_months (float), period (str like 'Q3 2026'). Optional: okr (str — pinned at top), method (default 'rice'), buffer_pct (default 20). Returns {markdown, scheduled[], deferred[], capacity_used_pw, capacity_total_pw, buffer_pw, method, period}.
Inputs: capacity_engineer_months (required), period (required), okr, method, +3 more.
generate_spec_draftA
Produce a markdown spec draft for one initiative, shaped so mk-spec-master.parse_spec(raw_text=...) can ingest it verbatim. Three templates: 'default' (title / source / OKR / context / acceptance criteria / out-of-scope), 'lite' (title / context / acceptance criteria), 'detailed' (default + risks + dependencies + estimated effort). Appends a spec_generated decision to the index. Returns {markdown, suggested_filename, template_used, ready_for_mk_spec_master, next_step_hint}.
Inputs: initiative_id (required), template.
get_decision_signatureA
Scan history + index for chronic patterns: ghost initiatives (appear in top-10 in >50% of snapshots but never spec_generated), score whiplash (RICE swings >50% between snapshots → bad data quality), orphan OKRs (OKRs in the index with zero initiatives in the current top-10). Use when a user asks 'which ideas keep getting punted' / 'why does this score keep moving' / 'which OKR has no execution'. Args: window_days (default 30). Returns {ghost_initiatives, score_whiplash, orphan_okrs, summary}.
Inputs: window_days.
get_plan_contextA
Read PLAN_PROJECT_ROOT/plan-knowledge.md (or fall back to built-in defaults if missing). Call near the start of a planning session so the same methodology + domain glossary colours every scoring decision that follows. Optional section filters to a single heading (partial-match, case-insensitive) — e.g. section='RICE' returns just the RICE block. Returns {source: 'file'|'builtin', content, ...}.
Inputs: section.
get_planning_historyA
Return trend deltas (current vs ~7 days ago / vs window_days ago) for the top-10 RICE-ranked backlog snapshots archived by rank_backlog. Surfaces churn (entries added/dropped) plus the average score of the current top-10. Use when a user asks 'are we improving' / 'show me the trend' / 'is the same idea always at the top'. Returns {snapshots_count, trend_7d, trend_30d, summary}.
Inputs: window_days.
get_plan_source_infoA
Return the active initiative source (selected via PLAN_SOURCE env var) plus all adapters built into this server. Call first in any session so the AI knows whether to expect markdown / Linear / JIRA / Notion semantics. Returns {active, available, version}.
Inputs: no named parameters.
get_telemetryA
Aggregate the tool-usage log written by this server. Surfaces: which tools are called most, which fail most (error rate), p50 / p95 / p99 latency, and which declared tools have never been called in the window (dead surface). Records contain only tool name + timing + ok flag — argument values are never logged. Use when a user asks 'what's the AI actually using' / 'which tools are slow' / 'which tools are unused'. Args: window_days (default 7). Returns {calls_total, calls_by_tool, error_rate_pct, p50_ms, p95_ms, p99_ms, top_tools[], dead_tools[]}.
Inputs: window_days.
init_plan_knowledgeA
Create PLAN_PROJECT_ROOT/plan-knowledge.md from a starter template. The file carries methodology (RICE, WSJF, Impact-Effort, OKR mapping, INVEST, personas / job-stories, decision-log convention) plus TODO sections for active OKRs / personas / strategic bets / tech-debt zones / glossary / roadmap rhythm. Other mk-plan-master tools lean on this indirectly via get_plan_context. Idempotent — refuses to overwrite an existing file unless overwrite=true. Optional project_name labels the file. Override location via the PLAN_KNOWLEDGE_FILE env var.
Inputs: project_name, overwrite.
list_initiativesA
Enumerate product initiatives from the active source. For markdown_local this globs PLAN_PROJECT_ROOT/initiatives/*.md and reads YAML-ish frontmatter; for linear it queries the GraphQL API for issues in triage / backlog / unstarted state types; for jira it runs JQL filtered to statusCategory='To Do'; for notion it queries the database and filters to status in (Triage / Backlog / Idea). Optional filters: status (string — adapter-specific), label (string — single label match), limit (int, default 50). Returns {source, count, initiatives[]}.
Inputs: status, label, limit.
rank_backlogA
Score every initiative the active adapter exposes and return the top-N descending. Pure arithmetic, no LLM call — the rationale string is generated from the breakdown so the output stays deterministic. Optional filters mirror list_initiatives: status, label. method defaults to 'rice'; limit defaults to 10. Auto-archives a snapshot to .mk-plan-master/history/.json so get_planning_history / get_decision_signature can compute trend deltas across cycles (debounced to 5 minutes by default). Returns {method, count, ranking[]}.
Inputs: method, status, label, limit.
score_initiativeA
Score one initiative with RICE or Impact-Effort. Pass initiative_id to score a source-resolved record (RICE inputs are read from raw_metadata) or raw_text + overrides for an ad-hoc score without a source record. method = 'rice' (default) or 'impact_effort'. overrides = {reach, impact, confidence, effort} — any subset; takes precedence over what was in the source. RICE tier thresholds: P0 > 25, P1 10..25, P2 3..10, P3 < 3. Every call with initiative_id appends a scored decision to the index at PLAN_PROJECT_ROOT/.mk-plan-master/index.json. Returns {initiative_id, method, score, breakdown, tier, rationale, stored}.
Inputs: initiative_id, raw_text, method, overrides.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 15 tools
Each tool has a clearly distinct purpose: adding, analyzing, fetching, scoring, ranking, generating, etc. There is no overlap in functionality.
All tool names follow a consistent verb_noun pattern in snake_case (e.g., add_initiative, analyze_initiative, get_plan_context). No mixing of conventions.
15 tools is a well-scoped set for a product planning server, covering the full lifecycle from initiative capture to roadmap generation without being overwhelming.
The tool surface is comprehensive: CRUD-like operations (add, fetch, list, score), analysis, ranking, roadmap generation, history tracking, and telemetry. No obvious gaps.
Maintenance
Related MCP Connectors
MCP server for generating rough-draft project plans from natural-language prompts.
A project planning board your AI reads and updates over MCP, so the plan stays one plan.
AI workflow/MCP implementation package planner.
Your product team's shared strategic memory — an MCP server your AI tools reason over.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn AI-native specification framework that enables deep requirements analysis and structured project planning through intelligent Q\&A workflows. The MCP server provides tools for project initialization, requirement analysis, and the generation of living documentation like development plans and architecture specs.3 npmApache 2.0
- AlicenseAqualityDmaintenanceAI 規格大師 — MCP server bridging specs (Linear / JIRA / GitHub Issues / Notion / Markdown / Figma) to tests, with bidirectional traceability and a spec-quality coach. Sibling to mk-qa-master.182MIT
- AlicenseNot gradedqualityDmaintenanceMCP server that provides project guardrails including prior art research, project status checks, next task retrieval, and quality gate enforcement for AI-assisted development.19 npmMIT
- AlicenseNot gradedqualityDmaintenanceA comprehensive MCP server for managing product initiatives, architecture decisions, requirements, and releases, enabling AI tools to interact with architectural documentation and planning.MIT