MCP Methodology Server

🎯 DEVELOPMENT & PROJECT PLANNING GUIDE
4-step methodology server providing architecture planning, development standards, and quality assurance for enterprise-grade software projects.

✅ Fully Compatible with Claude Desktop, Cursor IDE & Kiro IDE - 37 Methodology Tools Available

🚀 Quick Start (5 minutes)

Claude Desktop Integration

✅ FULLY FUNCTIONAL - 37 Methodology Tools Available

# 1. Install via npx (recommended)
npx mcp-methodology-server --help

# 2. Add to Claude Desktop config (~/.config/claude-desktop/mcp.json):
{
  "mcpServers": {
    "methodology": {
      "command": "npx",
      "args": ["--yes", "mcp-methodology-server@latest", "--stdio"]
    }
  }
}

# 3. Restart Claude Desktop
# ✅ You should see 37 methodology tools available immediately

Cursor IDE Integration

✅ FULLY FUNCTIONAL - 37 Methodology Tools Available

# Step 1: Get your npx path
which npx
# Example result: /Users/yourname/.nvm/versions/node/v22.11.0/bin/npx

# Step 2: Get the directory that contains npx
dirname $(which npx)
# Example result: /Users/yourname/.nvm/versions/node/v22.11.0/bin

Create ~/.cursor/mcp.json with YOUR paths:

{
  "mcpServers": {
    "mcp-methodology-server": {
      "command": "STEP_1_WHICH_NPX",
      "args": ["--yes", "mcp-methodology-server@latest", "--stdio"],
      "env": {
        "PATH": "STEP_2_GET_NPX_DIRECTORY:/usr/bin:/bin:/usr/sbin:/sbin"
      }
    }
  }
}

Real example with actual paths:

{
  "mcpServers": {
    "mcp-methodology-server": {
      "command": "/Users/marco/.nvm/versions/node/v22.11.0/bin/npx",
      "args": ["--yes", "mcp-methodology-server@latest", "--stdio"],
      "env": {
        "PATH": "/Users/marco/.nvm/versions/node/v22.11.0/bin:/usr/bin:/bin:/usr/sbin:/sbin"
      }
    }
  }
}

Step 4: Restart Cursor IDE ✅ You should see "37 tools enabled" in green status

📋 Cursor Configuration Steps:

1. Step 1: Run which npx → Copy result to "command" field
2. Step 2: Run dirname $(which npx) → Copy result to "PATH" field
3. Create config: Edit ~/.cursor/mcp.json using Step 1 and Step 2 results
4. Validate: Check JSON syntax and restart Cursor
5. Verify: Look for "37 tools enabled" green status

💡 Key Points for Cursor:

• command: Use EXACT result of which npx (full path to npx)
• PATH: Use bin directory (result of dirname $(which npx))
• Both paths must match: Same Node.js version in both command and PATH
• JSON syntax: Validate with online JSON checker if having issues
• Full restart: Close and reopen Cursor completely after config changes

Kiro IDE Integration (AWS)

✅ FULLY FUNCTIONAL - 37 Methodology Tools Available

Prerequisites

• Install Kiro IDE (AWS's AI-powered IDE)

Configuration Steps

Step 1: Enable MCP Support

1. Open Settings: Cmd + , (Mac) or Ctrl + , (Windows/Linux)
2. Search for "MCP"
3. Enable the MCP support setting

Step 2: Create MCP Configuration
Create or edit your Kiro MCP configuration file with the following settings:

{
  "mcpServers": {
    "methodology": {
      "command": "npx",
      "args": [
        "--yes",
        "mcp-methodology-server@latest",
        "--stdio"
      ],
      "env": {},
      "disabled": false,
      "autoApprove": [
        "agent_analyzer",
        "agent_pm",
        "agent_refactoring",
        "agent_smoke",
        "agent_worker",
        "agents_overview",
        "architecture_deep_dive",
        "business_requirements_standards",
        "checkpoint",
        "claude_integration",
        "current_task_dashboard",
        "cursor_integration",
        "enterprise_requirements_standards",
        "example_business_ecommerce_app",
        "example_business_ecommerce_plan",
        "example_cto_agent_quick_request",
        "example_cto_detailed_request",
        "example_enterprise_agent_features",
        "example_enterprise_master_plan",
        "example_personal_todo_app",
        "example_personal_todo_plan",
        "examples_overview",
        "feature_engineering_standards",
        "framework_standards",
        "guidance",
        "ides_overview",
        "legacy_code_analysis_standards",
        "overview",
        "personal_requirements_standards",
        "prototype_requirements_standards",
        "search_methodology",
        "task_management_standards",
        "template_detailed_request",
        "template_framework_documentation",
        "template_project_memory",
        "template_quick_product_request",
        "testing_comprehensive"
      ]
    }
  }
}

Step 3: Verification

1. Ask Kiro's CHAT: "Can you validate that the new MCP server methodology is active and that you can see all its tools?"
2. Verify that Kiro confirms access to all 37 methodology tools
3. Test functionality with: "Help me start a new project"

📋 Kiro Configuration Notes:

• No Installation Required: npx --yes downloads automatically, no global install needed
• No Restart Needed: Configuration takes effect immediately, verify through CHAT
• Auto-Approved Tools: All 37 tools pre-approved for seamless experience
• Methodology Checkpoint: NEW enforcement tool for development discipline
• Chat Verification: Only way to confirm MCP tools are active is through Kiro's CHAT

For detailed MCP setup: Kiro MCP Documentation

💡 How to Use MCP Methodology Effectively

The MCP Methodology Server transforms how you approach software development by providing a structured, AI-assisted workflow. Here's how to maximize its value:

🎯 The 4-Step Development Process

Every project follows this proven methodology:

1. Step 1 - Project Requirements: Define what you're building
2. Step 2 - Task Breakdown: Break work into manageable tasks
3. Step 3 - Implementation: Build with quality standards
4. Step 4 - Validation: Test and validate completeness

The MCP server guides you through each step with specific tools and templates.

🚀 Creating New Projects

Workflow: From Idea to Architecture in Minutes

For Quick Projects (MVPs, Prototypes): Tell your AI agent: "Use the quick project template to help me plan a [type] application"

• Gets template from template_quick_product_request
• Guides through essential requirements only
• Perfect for rapid prototyping

For Enterprise Projects (Production Apps): Tell your AI agent: "Use the detailed project template to plan a comprehensive [type] system"

• Gets template from template_detailed_request
• Covers architecture, security, scalability
• Includes compliance and documentation requirements

Example Complete Workflow:

1. "I want to create an ecommerce platform, use the detailed template"
2. AI gets enterprise planning template
3. "Now create the architecture plan using business standards"
4. AI uses business_requirements_standards + examples
5. "Break this into development tasks following TDD methodology"
6. AI uses software_requirements_standards for task breakdown
7. "Validate our plan against the 4-step methodology"
8. AI uses checkpoint to verify compliance

Result: Complete project plan ready for implementation in 15 minutes.

🔧 Working with Existing Projects

Workflow: Enhance and Modernize Effectively

Adding New Features: Your AI agent will:

• Use software_requirements_standards for TDD approach
• Apply feature_engineering_standards for clean implementation
• Follow checkpoint to ensure quality gates

Integrating Legacy Systems: Your AI agent will:

• Use legacy_code_analysis_standards for migration planning
• Apply compatibility patterns and modernization strategies
• Ensure new code follows current standards while respecting existing architecture

Example Feature Addition:

1. "Add payment processing to my React ecommerce app"
2. AI uses feature_engineering_standards + business_requirements
3. Creates test-first implementation plan
4. Follows TDD red-green-refactor cycle
5. Validates against security and compliance standards

🐛 Bug Fixes & Quality Assurance

Workflow: Fix Issues with Methodology Discipline

Bug Fix Process:

1. Reproduce: Use TDD to create failing test that reproduces the bug
2. Fix: Write minimal code to make test pass
3. Refactor: Clean up while keeping tests green
4. Validate: Ensure no regressions using full test suite

Quality Validation: Your AI agent uses checkpoint before any development action to:

• Verify current methodology step compliance
• Check if proper tasks are created before coding
• Ensure quality standards are being followed
• Prevent shortcuts that compromise code quality

📐 Architecture Planning & Validation

Workflow: Design and Validate System Architecture

Architecture Design:

• Use example_enterprise_master_plan for comprehensive system design
• Apply software_requirements_standards for technical decisions
• Follow domain-driven design (DDD) patterns
• Include testing, security, and scalability considerations

Architecture Validation: Your AI agent will:

• Check current architecture against enterprise standards
• Validate adherence to DDD principles
• Ensure proper separation of concerns
• Verify testing and deployment strategies

Example Architecture Review:

1. "Validate my microservices architecture against enterprise standards"
2. AI uses software_requirements_standards + enterprise examples
3. Checks DDD compliance, testing strategy, deployment patterns
4. Provides specific recommendations for improvements
5. Creates action plan for architecture improvements

🏢 Enterprise Framework Documentation

Problem Solved: When AI agents encounter unknown frameworks in enterprise environments, they can't provide effective programming assistance without documentation about those internal frameworks.

Solution: The MCP Methodology Server now provides two specialized tools that help AI agents understand and work with undocumented enterprise frameworks:

Framework Documentation Tools:

• framework_standards - Complete standards for documenting internal frameworks so AI can understand them
• template_framework_documentation - Universal template for creating AI-friendly framework documentation

How It Works:

1. AI Agent Encounters Unknown Framework: Cursor detects a framework it doesn't know (e.g., "InternalDesignSystem")
2. AI Calls Framework Standards: Gets comprehensive documentation standards via framework_standards
3. AI Calls Framework Template: Gets structured template via template_framework_documentation
4. User Documents Framework: Following the template, user creates documentation for their internal framework
5. AI Can Now Program: With proper documentation, AI can effectively program with the previously unknown framework

Real-World Example:

User: "Add a new component using our InternalDesignSystem"
AI: "I'm not familiar with InternalDesignSystem. Let me get the framework documentation standards..."
→ Calls framework_standards + template_framework_documentation
→ Guides user through documenting InternalDesignSystem properly
→ Once documented, AI can effectively program with InternalDesignSystem

Business Value: Extends AI programming effectiveness from 60% (mainstream frameworks only) to 90% (complete enterprise technology stack including internal frameworks).

🛠️ Complete Methodology Tools Reference

Core Methodology:

• guidance - Complete 4-step process overview
• overview - Enterprise development summary
• checkpoint - MANDATORY before any development action
• search_methodology - Find specific guidance in any document

Project Planning:

• template_quick_product_request - 5-minute project setup
• template_detailed_request - Comprehensive enterprise planning
• current_task_dashboard - Instructions for task management

Development Standards:

• software_requirements_standards - TDD, DDD, quality requirements
• feature_engineering_standards - Feature development guidelines
• business_requirements_standards - Business application standards
• personal_requirements_standards - Personal project guidelines
• legacy_code_analysis_standards - Legacy system migration

Examples & References:

• examples_overview - All available examples summary
• example_enterprise_agent_features - Enterprise feature specifications
• example_enterprise_master_plan - Complete enterprise architecture
• example_business_ecommerce_app - Business app feature example
• example_business_ecommerce_plan - Business app architecture
• example_personal_todo_app - Personal app features
• example_personal_todo_plan - Personal app architecture
• example_cto_detailed_request - CTO-level project request
• example_cto_agent_quick_request - Quick CTO project template

📋 Real-World Usage Patterns

Pattern 1: New Startup MVP

"I need to create a SaaS MVP quickly but with good architecture foundation"
→ Uses quick template + business standards + enterprise examples
→ Result: Professional architecture that can scale

Pattern 2: Legacy System Modernization

"Modernize our PHP monolith to microservices while maintaining functionality"  
→ Uses legacy analysis + enterprise planning + migration patterns
→ Result: Systematic modernization plan with risk mitigation

Pattern 3: Feature Development in Existing App

"Add real-time chat to our React app with proper testing"
→ Uses feature engineering + TDD standards + methodology checkpoint
→ Result: Clean, tested, documented feature implementation

Pattern 4: Architecture Review & Improvement

"Review our current system and identify architectural improvements"
→ Uses methodology checkpoint + enterprise standards + validation
→ Result: Specific improvement plan with prioritized action items

🎯 Best Practices for Maximum Value

Always Start with Methodology Checkpoint: Before any development work, your AI agent should call checkpoint to:

• Understand what standards apply to your project type
• Verify you're following the correct methodology step
• Get relevant guidance for your current context

Use Templates for Consistency:

• Quick template for MVPs and prototypes
• Detailed template for production systems
• Examples for reference and inspiration

Follow the 4-Step Process:

1. Requirements → Use templates and standards to define project
2. Tasks → Break work into testable, manageable units
3. Implementation → Code with TDD/DDD standards
4. Validation → Test thoroughly and validate against requirements

Leverage Search for Specific Guidance: When you need specific information, use search_methodology to find relevant guidance across all methodology documents.

🚀 Autonomous Project Context Management

🎯 The Real Power: Self-Managing Project State

The MCP Methodology Server doesn't just provide guidance - it actively manages your project context and ensures continuity across any team changes.

Automatic Task Lifecycle Management:

• Creates tasks automatically based on requirements and project scope
• Updates project dashboard in real-time as work progresses
• Moves tasks through lifecycle: OPEN → IN_PROGRESS → DONE
• Tracks progress autonomously without manual intervention
• Validates methodology compliance at every step

Context Preservation Magic:

• Developer A works on 10 tasks across 2 weeks → leaves project
• Developer B joins team → complete context immediately available
• No handoff meetings, no lost documentation, no "where did we leave off?"
• Project state is always current, complete, and accessible

🔄 How Task Management Works

Your AI agent automatically handles:

1. Task Creation:

   "Add authentication to the app"
   → AI creates specific tasks: setup, tests, implementation, validation
   → Each task follows TDD methodology requirements
   → Dashboard updated with new OPEN tasks

2. Progress Tracking:

   → AI moves task to IN_PROGRESS when starting work
   → Updates task status as implementation progresses  
   → Validates against methodology checkpoints
   → Moves to DONE when tests pass and requirements met

3. Context Documentation:

   → Every decision automatically documented
   → Architecture choices explained and reasoned
   → Dependencies and relationships tracked
   → Quality gates and validation results recorded

🎯 Why This Changes Everything

The #1 Problem in Software Development: Context Loss

• Team member changes → lost institutional knowledge
• Return to project after months → forgot architecture decisions and reasoning
• Scale team → new developers start from zero understanding
• Handoffs between developers → information gaps and misunderstandings

The MCP Solution: Autonomous Context Management

• Every decision, task, and progress automatically documented with reasoning
• Any developer can pick up any project instantly with full context
• Self-updating project state with complete methodology compliance
• True development continuity across time and team changes
• Scalable team collaboration without knowledge silos

📈 Real Impact: Team Autonomy

Traditional Development:

❌ Developer leaves → 2 weeks to understand project
❌ Return after break → forgot architecture decisions  
❌ New team member → weeks of context building
❌ Handoff meetings → still miss critical details

With MCP Methodology:

✅ Developer leaves → replacement productive in 30 minutes
✅ Return after months → full context immediately available
✅ New team member → understands project architecture instantly  
✅ No handoff needed → complete context always accessible

🎯 The Ultimate Value

The MCP server solves the fundamental challenge of software development: maintaining project context and continuity. It doesn't just help you build better software - it enables truly autonomous development teams where context never gets lost, knowledge is always preserved, and any developer can contribute effectively to any project.

This is the paradigm shift from individual productivity tools to autonomous team intelligence.

🚀 Ready to Start? Configure your AI IDE above and begin with: "Use methodology checkpoint to help me plan my next development project"