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 package manager
• Claude Desktop or compatible MCP client

Installation

1. Clone the repository:

   git clone <repository-url>
   cd Coding_MCP
   

2. Install dependencies:

   uv sync
   

3. Configure Claude Desktop: Add this server configuration to your claude_desktop_config.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

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:

   uv venv
   .venv\Scripts\activate
   

2. Install in development mode:

   uv pip install -e .
   

3. Run the server directly (for testing):

   uv run python main.py
   

Testing the Server

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

# 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:

   @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:

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:

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
• 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