home / mcp / lifecycle mcp server

Lifecycle MCP Server

Provides lifecycle management for requirements, tasks, and architecture with traceability and automated state transitions.

Installation

Add the following to your MCP client configuration file.

Configuration

View docs

{
  "mcpServers": {
    "heffrey78-lifecycle-mcp": {
      "command": "lifecycle-mcp",
      "args": [],
      "env": {
        "LIFECYCLE_DB": "./lifecycle.db"
      }
    }
  }
}

You can manage the full software lifecycle inside Claude with the Lifecycle MCP Server. It tracks requirements, tasks, and architecture decisions, stores everything in a local SQLite database, and provides automated state transitions and traceability to keep your projects aligned from idea to implementation.

How to use

You interact with the Lifecycle MCP Server through Claude by adding a server configuration and then using its tools to create and manage requirements, tasks, and architecture decisions. The server exposes a comprehensive set of capabilities that let you model lifecycle states, link work items, and generate traceability dashboards.

How to install

Prerequisites you need to have before installing the server are Python and a method to run an MCP locally or via Claude. You will also use a SQLite database file to store lifecycle data.

# 1. Clone the project
git clone https://github.com/heffrey78/lifecycle-mcp.git
cd lifecycle-mcp

# 2. Install the server for development or usage
pip install -e .

# 3. Add the MCP server to Claude using one of the runtime options described below

Configuration and connection methods

You can run the MCP server locally in Claude in a few ways. The recommended approach is to install the server globally and then add it to Claude, or to run it from source with a runtime container such as uv or directly with Python. Each method uses the LIFECYCLE_DB environment variable to point to your SQLite database.

Best practices for setup

- Each project should have its own lifecycle.db file. Use LIFECYCLE_DB=./lifecycle.db to create the database in the current project, or provide an absolute path to a shared database. - Consider using a virtual environment to isolate dependencies and ensure repeatable installations. - Verify the MCP server is accessible from Claude after adding it, and start with a simple lifecycle example to confirm connectivity.

Project lifecycle tools overview

The Lifecycle MCP Server offers a complete set of tools to manage requirements, tasks, and architecture decisions, including creating and updating lifecycle states, tracing requirements through implementation, syncing tasks from external sources, exporting documentation, and generating architecture diagrams. You can start interviews to gather requirements, create ADRs for architectural decisions, and monitor project health through dashboards.

Security and troubleshooting notes

If you encounter issues connecting to the MCP, re-add the server in Claude, then start the server and verify there are no startup errors. If you see database lock errors, ensure only one server instance is running and the database file has proper permissions. Initialization creates the necessary schema on first run; you can reset by removing the database file.

Examples and scenarios

You can start an interactive requirement interview to gather context, then create requirements, link them to tasks, and record architecture decisions. You can export comprehensive project documentation or generate Mermaid diagrams to visualize relationships between requirements, tasks, and architecture.

Available tools

create_requirement

Create new requirements from interview data or analysis

update_requirement_status

Move requirements through lifecycle states with validation

query_requirements

Search and filter requirements by status, priority, type, or text

get_requirement_details

Get full requirement details including relationships and metadata

trace_requirement

Trace a requirement through its complete implementation lifecycle

create_task

Create implementation tasks linked to one or more requirements

update_task_status

Update task progress and assignment

query_tasks

Search and filter tasks by status, priority, assignee, or linked requirement

get_task_details

Get task details including dependencies and relationships

sync_task_from_github

Sync a single task with its linked GitHub issue changes

bulk_sync_github_tasks

Sync all tasks with their GitHub issues in bulk

create_architecture_decision

Record architecture decisions (ADRs) with full context

update_architecture_status

Update the status of an architecture decision with validation

query_architecture_decisions

Search and filter architecture decisions by status, type, linked requirements, or text

get_architecture_details

Get architecture decision details including linked requirements and reviews

add_architecture_review

Add review comments to architecture decisions

get_project_status

Get project health metrics and dashboards

start_requirement_interview

Start an interactive requirement gathering interview session

continue_requirement_interview

Continue an active requirement interview session with answers

start_architectural_conversation

Start an interactive architectural diagram conversation

continue_architectural_conversation

Continue architectural conversation and generate diagrams

export_project_documentation

Export comprehensive project documentation in markdown format

create_architectural_diagrams

Generate Mermaid diagrams for project visualization