Lifecycle MCP Server

A Model Context Protocol (MCP) server for comprehensive software lifecycle management. This server provides structured tracking of requirements, tasks, and architecture decisions through a SQLite database with full traceability and automated state management.

- Requirements Management: Create and manage software requirements with validation and lifecycle tracking
- Task Management: Track implementation tasks with hierarchical structure and effort estimation
- Architecture Decisions: Record ADRs (Architecture Decision Records) with full context
- Project Dashboards: Real-time project health metrics and status reporting
- Requirement Tracing: Complete traceability from requirements through implementation
- State Validation: Automatic validation of lifecycle state transitions
- Relationship Tracking: Many-to-many relationships between requirements, tasks, and architecture

# 1. Clone the repository git clone https://github.com/heffrey78/lifecycle-mcp.git cd lifecycle-mcp # 2. Install globally (easiest for using across projects) pip install -e . # 3. Go to any project where you want to use lifecycle management cd /path/to/your/project # 4. Add the MCP server to Claude claude mcp add lifecycle lifecycle-mcp -e LIFECYCLE_DB=/path/to/your/project/lifecycle.db # 5. Start using lifecycle tools in Claude!

If you want to useuv(faster Python package manager):

# macOS/Linux curl -LsSf https://astral.sh/uv/install.sh | sh # Or with homebrew brew install uv

git clone https://github.com/heffrey78/lifecycle-mcp.git cd lifecycle-mcp

For detailed examples and scenarios, seeUSAGE_EXAMPLES.md.

# From the lifecycle-mcp directory pip install -e . # Now from ANY project directory, add the server: claude mcp add lifecycle lifecycle-mcp -e LIFECYCLE_DB=./lifecycle.db

# Get the full path to the lifecycle-mcp directory LIFECYCLE_PATH="/path/to/lifecycle-mcp" # Replace with your actual path # From any project directory: claude mcp add lifecycle $(which uv) -- --directory $LIFECYCLE_PATH run server.py -e LIFECYCLE_DB=./lifecycle.db

# Get the full path to the server LIFECYCLE_PATH="/path/to/lifecycle-mcp" # Replace with your actual path # From any project directory: claude mcp add lifecycle $(which python) $LIFECYCLE_PATH/server.py -e LIFECYCLE_DB=./lifecycle.db

{ "mcpServers": { "lifecycle": { "command": "lifecycle-mcp", "env": { "LIFECYCLE_DB": "./lifecycle.db" } } } }

# Create a virtual environment for lifecycle-mcp cd /path/to/lifecycle-mcp python -m venv venv source venv/bin/activate # On Windows: venv\Scripts\activate # Install in the virtual environment pip install -e . # Find the venv's lifecycle-mcp command which lifecycle-mcp # Copy this path # Use the full path when adding to Claude claude mcp add lifecycle /path/to/venv/bin/lifecycle-mcp -e LIFECYCLE_DB=./lifecycle.db

{ "type": "FUNC", "title": "User Authentication System", "priority": "P1", "current_state": "No user authentication exists", "desired_state": "Secure user login with JWT tokens", "functional_requirements": ["Login with email/password", "JWT token generation"], "acceptance_criteria": ["User can login successfully", "Token expires after 24 hours"], "business_value": "Enables secure user access to protected features", "risk_level": "Medium" }

Move requirements through their lifecycle with validation.

- requirement_id(required): Requirement ID (e.g., "REQ-0001-FUNC-00")
- new_status(required): Target status - "Draft", "Under Review", "Approved", "Architecture", "Ready", "Implemented", "Validated", "Deprecated"
- comment(optional): Review comment or justification

- Draft → Under Review, Deprecated
- Under Review → Draft, Approved, Deprecated
- Approved → Architecture, Ready, Deprecated
- Architecture → Ready, Approved
- Ready → Implemented, Deprecated
- Implemented → Validated, Ready
- Validated → Deprecated

Search and filter requirements by various criteria.

- status(optional): Filter by status
- priority(optional): Filter by priority level
- type(optional): Filter by requirement type
- search_text(optional): Text search in title and desired state

Get comprehensive requirement information including all relationships.

- requirement_id(required): Requirement ID

Returns:Detailed report with basic info, problem definition, functional requirements, acceptance criteria, and linked tasks.

Trace a requirement through its complete implementation lifecycle.

- requirement_id(required): Requirement ID

Returns:Complete trace including requirement details, implementation tasks, and architecture decisions.

Create implementation tasks linked to requirements.

- requirement_ids(required): Array of requirement IDs to link
- title(required): Task title
- priority(required): Priority level - "P0", "P1", "P2", "P3"
- effort(optional): Effort estimation - "XS", "S", "M", "L", "XL"
- user_story(optional): User story description
- acceptance_criteria(optional): Array of acceptance criteria
- parent_task_id(optional): Parent task for subtasks
- assignee(optional): Task assignee

{ "requirement_ids": ["REQ-0001-FUNC-00"], "title": "Implement JWT token generation", "priority": "P1", "effort": "M", "user_story": "As a developer, I need JWT token generation so users can authenticate securely", "acceptance_criteria": ["Generate JWT with user claims", "Token expires in 24 hours"], "assignee": "john.doe@company.com" }

- task_id(required): Task ID (e.g., "TASK-0001-00-00")
- new_status(required): New status - "Not Started", "In Progress", "Blocked", "Complete", "Abandoned"
- comment(optional): Status update comment
- assignee(optional): New assignee

Search and filter tasks by various criteria.

- status(optional): Filter by status
- priority(optional): Filter by priority level
- assignee(optional): Filter by assignee
- requirement_id(optional): Filter by linked requirement

Get comprehensive task information including dependencies and relationships.

Returns:Detailed report with basic info, description, acceptance criteria, and linked requirements.

Sync individual task from GitHub issue changes with conflict detection.

- task_id(required): Task ID to sync with its linked GitHub issue

Returns:Sync status and any updates applied from GitHub issue data.

Sync all tasks with their GitHub issues in batch operation.

Returns:Summary of sync operations performed across all tasks with GitHub issue links.

Record architecture decisions (ADRs) with full context.

- requirement_ids(required): Array of requirement IDs addressed
- title(required): Decision title
- context(required): Decision context and background
- decision(required): The decision made
- consequences(optional): Decision consequences object
- decision_drivers(optional): Array of factors driving the decision
- considered_options(optional): Array of alternatives considered
- authors(optional): Array of decision authors

Update the status of an architecture decision with validation.

- architecture_id(required): Architecture ID (e.g., "ADR-0001")
- new_status(required): New status - "Proposed", "Accepted", "Rejected", "Deprecated", "Superseded", "Draft", "Under Review", "Approved", "Implemented"
- comment(optional): Status change comment

Search and filter architecture decisions by various criteria.

- status(optional): Filter by status
- type(optional): Filter by type (ADR, TDD, INTG)
- requirement_id(optional): Filter by linked requirement
- search_text(optional): Text search in title and context

Get comprehensive architecture decision information including all relationships and reviews.

- architecture_id(required): Architecture ID

Returns:Detailed report with basic info, context, decision details, drivers, options, consequences, linked requirements, and review history.

Add review comments to architecture decisions.

- architecture_id(required): Architecture ID
- comment(required): Review comment
- reviewer(optional): Reviewer name (default: "MCP User")

Get comprehensive project health metrics and dashboards.

- include_blocked(optional): Include blocked items analysis (default: true)

Returns:Dashboard with requirement overview, task statistics, completion percentages, and blocked items analysis.

Start an interactive requirement gathering interview session.

- project_context(optional): Description of the project or system
- stakeholder_role(optional): Role of the person being interviewed

Returns:Session ID and initial questions to guide requirement gathering.

{ "project_context": "E-commerce platform modernization", "stakeholder_role": "Product Manager" }

Continue an active interview session by providing answers to questions.

- session_id(required): Interview session ID from start_requirement_interview
- answers(required): Object containing answers to the current questions

Returns:Next set of questions or completion summary with created requirement.

{ "session_id": "a1b2c3d4", "answers": { "current_problem": "Users struggle with complex checkout process", "desired_outcome": "Streamlined one-click checkout experience", "success_criteria": "Checkout completion rate increases by 25%" } }

- Problem Identification: Understanding the current challenge
- Solution Definition: Defining the desired outcome and constraints
- Details Gathering: Collecting priority, type, and technical details
- Validation: Establishing acceptance criteria and success metrics
- Completion: Automatic requirement creation with interview summary

Export comprehensive project documentation in structured markdown format.

- project_name(optional): Name for the project used in filenames (default: "project")
- include_requirements(optional): Include requirements documentation (default: true)
- include_tasks(optional): Include tasks documentation (default: true)
- include_architecture(optional): Include architecture documentation (default: true)
- output_directory(optional): Directory to save exported files (default: ".")

Returns:List of exported files with their paths.

- {project_name}-requirements.md- Complete requirements documentation grouped by type
- {project_name}-tasks.md- Task documentation grouped by status with linked requirements
- {project_name}-architecture.md- Architecture decisions with context, decisions, and consequences

{ "project_name": "ecommerce-platform", "include_requirements": true, "include_tasks": true, "include_architecture": true, "output_directory": "./docs" }

Generate Mermaid diagrams for project architecture and relationships visualization.

- diagram_type(optional): Type of diagram - "requirements", "tasks", "architecture", "full_project", "directory_structure", "dependencies" (default: "full_project")
- requirement_ids(optional): Array of specific requirement IDs to include
- include_relationships(optional): Include relationship arrows in diagrams (default: true)
- output_format(optional): Output format - "mermaid", "markdown_with_mermaid" (default: "mermaid")
- interactive(optional): Start interactive conversation for complex diagrams (default: false)

Returns:Mermaid diagram code or markdown-wrapped diagram.

- requirements: Flowchart showing requirement hierarchy by type with status colors
- tasks: Task hierarchy with parent-child relationships and status indicators
- architecture: Architecture decisions with status-based styling
- full_project: High-level overview showing relationships between requirements, tasks, and architecture
- directory_structure: Project directory structure visualization
- dependencies: Task dependency graph showing blocking relationships