# Functional Requirements MCP Server

A Model Context Protocol (MCP) server that provides AI-powered prompts for generating user stories, requirements, technical specifications, and other software development documentation.

## 🎯 Overview

This MCP server offers a collection of specialized prompts designed to streamline the software development lifecycle by automating the creation of structured documentation. It focuses on functional requirements analysis and technical documentation generation.

## ✨ Features

### Core Functionality

- **User Story Creation**: Generate detailed user stories with proper formatting and structure
- **Requirements Generation**: Convert user stories into functional and non-functional requirements
- **Technical Specifications**: Transform requirements into detailed technical documentation
- **Meeting Documentation**: Extract action items and decisions from meeting notes
- **Release Notes**: Create professional release documentation
- **Architecture Decision Records (ADRs)**: Document technical decisions and rationale

### Structured Data Models

- **UserStory Model**: Comprehensive data structure with MoSCoW prioritization
- **Step-by-Step Processes**: Support for normal and exceptional flow documentation
- **Actor Management**: Track stakeholders and system users

## 🚀 Quick Start

### Prerequisites

- Python 3.13 or higher
- [uv](https://docs.astral.sh/uv/) package manager
- Claude Desktop or compatible MCP client

### Installation

1. **Clone the repository**:

   ```powershell
   git clone <repository-url>
   cd Coding_MCP
   ```

2. **Install dependencies**:

   ```powershell
   uv sync
   ```

3. **Configure Claude Desktop**:
   Add this server configuration to your `claude_desktop_config.json`:

   ```json
   {
     "mcpServers": {
       "Functional Requirements": {
         "command": "C:\\Users\\<your-username>\\AppData\\Local\\Programs\\Python\\Python311\\Scripts\\uv.EXE",
         "args": [
           "run",
           "--with",
           "mcp[cli]",
           "mcp",
           "run",
           "C:\\Users\\<your-username>\\source\\repos\\Coding_MCP\\main.py"
         ]
       }
     }
   }
   ```

4. **Restart Claude Desktop** to load the new server.

## 📖 Usage Guide

### Available Prompts

#### 1. Create User Story

**Purpose**: Generate structured user stories from contextual information.

**Usage**: Provide context about a feature or requirement, and the prompt will create a properly formatted user story following the "As a [actor], I want [feature] so that [benefit]" convention.

**Output**: JSON-structured user story with:

- Unique identifier and name
- Definition following user story conventions
- Pre/post conditions
- Actors involved
- Normal and exceptional process flows
- MoSCoW prioritization with explanation
- Related requirements

#### 2. Create Requirements

**Purpose**: Transform user stories into detailed functional and non-functional requirements.

**Input**: UserStory object
**Output**: Comprehensive requirements covering:

- Functional requirements (system capabilities)
- Non-functional requirements (performance, security, usability)
- Technical constraints and dependencies
- Acceptance criteria for testing

#### 3. Technical Specification Writer

**Purpose**: Convert requirements into detailed technical specifications.

**Output Structure**:

- Overview and Scope
- System Architecture
- Detailed Design (APIs, data models, database design)
- Implementation Details
- Integration Points
- Quality Attributes

#### 4. Meeting Summary Generator

**Purpose**: Extract structured information from meeting notes.

**Output Includes**:

- Key decisions made
- Action items with owners and due dates
- Discussion points and open questions
- Next steps and dependencies
- Parking lot items

#### 5. Release Notes Creator

**Purpose**: Generate professional, user-facing release documentation.

**Sections Include**:

- What's New (features and enhancements)
- Improvements (performance, UX, developer experience)
- Bug Fixes
- Security Updates
- Breaking Changes with migration guides
- Technical details and acknowledgments

#### 6. Architecture Decision Record (ADR)

**Purpose**: Document technical decisions with proper rationale.

**Structure**:

- Status and decision makers
- Context and problem statement
- Options considered with pros/cons
- Decision rationale
- Implementation plan
- Consequences and risks
- Compliance considerations

## 🏗️ Project Structure

```plaintext
Coding_MCP/
├── main.py                 # MCP server with prompt definitions
├── pyproject.toml         # Project configuration and dependencies
├── uv.lock               # Dependency lock file
├── models/
│   ├── user_story.py     # UserStory and Step data models
│   └── requirements.py   # Requirements-related models
├── prompts/              # (Future: Additional prompt templates)
└── __pycache__/         # Python bytecode cache
```

## 🔧 Development

### Local Development Setup

1. **Activate the virtual environment**:

   ```powershell
   uv venv
   .venv\Scripts\activate
   ```

2. **Install in development mode**:

   ```powershell
   uv pip install -e .
   ```

3. **Run the server directly** (for testing):

   ```powershell
   uv run python main.py
   ```

### Testing the Server

You can test individual prompts by running the server locally and using the MCP client tools:

```powershell
# Run the server
uv run mcp run main.py

# In another terminal, test prompts
uv run mcp call main.py prompts/list
```

### Adding New Prompts

1. Define your prompt function in `main.py`:

   ```python
   @mcp.prompt(title="your prompt title", description="Description of what it does")
   def your_prompt_function(input_parameter: str) -> str:
       return f"""Your prompt template here with {input_parameter}"""
   ```

2. Follow the established patterns for structured output and clear instructions.

3. Test your prompt thoroughly before deployment.

## 📊 Data Models

### UserStory Model

The `UserStory` class provides a comprehensive structure for capturing user requirements:

```python
class UserStory(BaseModel):
    id: str                           # Unique identifier
    name: str                         # Concise title
    definition: str                   # "As a..., I want..., so that..."
    pre_condition: Optional[str]      # Required state before execution
    post_condition: Optional[str]     # Expected state after completion
    actors: List[str]                 # Involved stakeholders
    normal_flow: List[Step]           # Happy path steps
    exceptional_flows: List[Step]     # Error/alternative paths
    moscow: MoSCoW                    # Priority (Must/Should/Could/Won't Have)
    moscow_explanation: Optional[str] # Priority rationale
    requirements: List[str]           # Related requirement references
```

### Step Model

For process flow documentation:

```python
class Step(BaseModel):
    id: str      # Step identifier (e.g., "1", "2a", "3b")
    action: str  # Description of what happens
```

## 🔒 Security Considerations

- The server processes text input only - no file system access
- All prompts generate documentation, not executable code
- Input validation is handled by Pydantic models
- No external API calls or network access required

## 🤝 Contributing

1. Fork the repository
2. Create a feature branch: `git checkout -b feature/new-prompt`
3. Add your changes and tests
4. Commit with clear messages: `git commit -m "Add new prompt for..."`
5. Push and create a pull request

### Code Style

- Follow PEP 8 for Python code
- Use type hints for all function parameters and returns
- Add docstrings for new models and complex functions
- Maintain consistent prompt formatting and structure

## 📄 License

[Add your license information here]

## 🆘 Troubleshooting

### Common Issues

**Server not appearing in Claude Desktop**:

- Verify the path in `claude_desktop_config.json` is correct
- Ensure uv is installed and accessible
- Check that Python 3.11+ is installed
- Restart Claude Desktop after configuration changes

**Import errors**:

- Run `uv sync` to ensure all dependencies are installed
- Verify you're using Python 3.11 or higher

**Prompt not working as expected**:

- Check the prompt formatting and structure
- Ensure input parameters match the expected types
- Review the output for any parsing errors

### Getting Help

- Check the [MCP documentation](https://modelcontextprotocol.io/)
- Review existing prompt implementations in `main.py`
- Create an issue for bugs or feature requests

## 🔮 Future Enhancements

- Additional prompt templates for specific domains
- Integration with project management tools
- Export capabilities for generated documentation
- Batch processing for multiple user stories
- Custom template support
- Integration with version control systems

---

**Made with ❤️ for better software documentation**