Openai MCP

🚀 MCP Code Specification

This MCP code specification aims to ensure the high - quality, consistency, and maintainability of the project, while also enhancing development efficiency and team collaboration.

✨ Features

Basic Rules

1. Naming Conventions
   • Variable and function names must use snake_case.
   • Class names use PascalCase.
   • Constants are in all uppercase, with words separated by underscores (UPPER_SNAKE_CASE).
2. Code Format
   • Each function or class must have comments before and after to describe its functionality.
   • Use 4 spaces for code block indentation.
   • The line length should not exceed 120 characters. Wrap lines when necessary.
   • Tab characters are prohibited. Use spaces for indentation uniformly.
3. File Structure
   • Each file must have a module - level docstring.
   • Related functions and classes are logically grouped, with an empty line separating each group.
   • Add an empty line after importing modules.
4. Comments
   • Add block comments to explain important logic.
   • Add comments before private methods to describe their purposes.
   • Separate comments from code by at least one empty line.
5. Exception Handling
   • There must be a try - except block wherever an exception may be thrown.
   • Custom exceptions should inherit from BaseException and be placed in a separate file.
   • Exception information should include an error code and a detailed description.
6. Logging
   • Use the logging module to record logs.
   • Log levels are divided into DEBUG, INFO, WARNING, ERROR, and CRITICAL.
   • Log INFO - level and above for important operations.

Advanced Specifications

1. Dependency Management
   • Manage all third - party libraries using pipenv or poetry.
   • The environment file (e.g., Pipfile) must include all project dependencies.
   • Direct installation of development - version dependencies is prohibited.
2. Testing Requirements
   • Each functional module must have unit tests.
   • Test cases should cover all major code paths.
   • Use pytest for testing and output a coverage report.
3. Documentation Writing
   • The project provides complete API documentation and user manuals.
   • Generate documentation using Sphinx or similar tools.
   • Each module, class, and function has a detailed docstring.
4. Version Control
   • Use Git for version management.
   • Commit messages follow the Conventional Commits specification.
   • The project has a clear branch strategy and merge process.

Code Review

1. Pre - submission Checks
   • Run lint tools to check code format.
   • Execute unit tests to ensure all test cases pass.
   • Ensure no sensitive information is exposed.
2. Code Style
   • Follow PEP8 and the Google Python Style Guide.
   • Keep the code concise and avoid complex logic.
   • Focus on code readability and maintainability.
3. Security Specifications
   • Input Validation: All external inputs must be validated.
   • Access Control: Permission checks are required for sensitive operations.
   • Fix security vulnerabilities in a timely manner and update dependencies.

Deployment Requirements

1. Environment Preparation
   • Ensure the production environment is consistent with the development environment.
   • Configure environment variables to manage settings for different environments.
   • Use containerized deployment (Docker).
2. Configuration Management
   • Use Ansible or Chef for configuration management.
   • Version - control configuration files to avoid hard - coding.
   • Support dynamic configuration and hot - reloading.
3. Monitoring and Alarms
   • Deploy the Prometheus monitoring system.
   • Set reasonable alarm thresholds.
   • Provide log analysis tools.

Project Maintenance

1. Code Repository Management
   • Regularly clean up unused code and dependencies.
   • Address technical debt to maintain code quality.
   • Maintain the project's maintainability and scalability.
2. Version Release
   • Use semantic versioning (SEMVER).
   • Update the CHANGELOG before release.
   • Provide upgrade guides and migration instructions.
3. Community Contribution
   • Welcome external developers to contribute code.
   • Establish clear contribution processes and specifications.
   • Maintain good relationships within the open - source community.