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.

Related MCP server: Spec Workflow MCP

✨ 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