Template MCP Server
Description
A production-ready template for developing Model Context Protocol (MCP) servers using Python and FastMCP. This server provides a foundation for creating MCP-compliant servers with comprehensive examples of tools, structured logging, configuration management, and containerized deployment.
The template includes three example MCP tools: a multiply calculator, a code review prompt generator, and a Red Hat logo resource handler. It demonstrates best practices for MCP server development including proper error handling, health checks, multiple transport protocols (HTTP, SSE, streamable-HTTP), SSL support, and comprehensive development tooling.
Architecture
System Architecture
Control Flow
Code Structure
Key Components
main.py
: Application entry point with configuration validation, error handling, and uvicorn server startupapi.py
: FastAPI application setup with transport protocol selection (HTTP/SSE/streamable-HTTP) and health endpointsmcp.py
: Core MCP server class that registers tools using FastMCP decoratorssettings.py
: Environment-based configuration using Pydantic BaseSettings with validationtools/
: MCP tool implementations demonstrating arithmetic, prompts, and resource access patternsutils/pylogger.py
: Structured JSON logging using structlog with comprehensive processors
Current MCP Tools
multiply_numbers
: Demonstrates basic arithmetic operations with error handlingread_redhat_logo_content
: Shows resource access patterns with base64 encodingget_code_review_prompt
: Illustrates prompt generation for code analysis
How to Run the Code Locally
Prerequisites
Python 3.12 or higher
uv (fast Python package installer and resolver)
Setup
Install uv (if not already installed):
# On macOS/Linux: curl -LsSf https://astral.sh/uv/install.sh | sh # On MacOS using brew brew install uv # On Windows: powershell -c "irm https://astral.sh/uv/install.ps1 | iex" # Or with pip: pip install uvClone the repository:
git clone https://github.com/redhat-data-and-ai/template-mcp-server cd template-mcp-serverCreate and activate a virtual environment with uv:
uv venv # Activate the virtual environment: # On macOS/Linux: source .venv/bin/activate # On Windows: .venv\Scripts\activateInstall the package and dependencies:
# Install in editable mode with all dependencies uv pip install -e .Configure environment variables:
cp .env.example .env # Edit .env file with your configurationRun the server:
# Using the installed console script template-mcp-server # Or directly with Python module python -m template_mcp_server.src.main # Or using uv to run directly uv run python -m template_mcp_server.src.main
Configuration Options
The server configuration is managed through environment variables:
Variable | Default | Description |
|
| Server bind address |
|
| Server port (1024-65535) |
|
| Transport protocol (
,
,
) |
|
| SSL private key file path |
|
| SSL certificate file path |
|
| Logging level (
,
,
,
,
) |
Using Podman
Build and run with Podman Compose:
podman-compose up --buildOr build manually:
podman build -t template-mcp-server . podman run -p 3000:3000 --env-file .env template-mcp-server
Verify Installation
Health check:
curl http://localhost:3000/healthTest MCP tools:
# Test multiply tool via MCP endpoint curl -X POST "http://localhost:3000/mcp" \ -H "Content-Type: application/json" \ -d '{"method": "tools/call", "params": {"name": "multiply_numbers", "arguments": {"a": 5, "b": 3}}}'
How to Test the Code Locally
Development Environment Setup
Install development dependencies:
uv pip install -e ".[dev]"Install pre-commit hooks:
pre-commit install
Running Tests
The project includes a comprehensive test suite with 81+ tests covering unit tests, integration tests, and various edge cases.
Run all tests:
pytestRun tests with coverage reporting:
pytest --cov=template_mcp_server --cov-report=html --cov-report=termRun tests by category:
# Unit tests only pytest -m unit # Integration tests only pytest -m integration # Slow running tests pytest -m slow # Tests requiring network access pytest -m networkRun specific test modules:
# Test individual components pytest tests/test_multiply_tool.py -v pytest tests/test_redhat_logo.py -v pytest tests/test_code_review_prompt.py -v pytest tests/test_settings.py -v pytest tests/test_mcp_server.py -v # Run integration tests pytest tests/test_integration.py -vRun tests with different output formats:
# Verbose output with detailed test names pytest -v # Short traceback format pytest --tb=short # Quiet output (minimal) pytest -q
Code Quality Checks
Linting and formatting with Ruff:
# Check for issues ruff check . # Auto-fix issues ruff check . --fix # Format code ruff format .Type checking with MyPy:
mypy template_mcp_server/Docstring validation:
pydocstyle template_mcp_server/ --convention=googleRun all pre-commit checks:
pre-commit run --all-files
Test Suite Overview
The project includes a comprehensive test suite with the following structure:
Test Category | Count | Description |
Unit Tests | 71 | Individual component testing with mocking |
Integration Tests | 10 | End-to-end workflow testing |
Total Tests | 81+ | Complete test coverage |
Test Files:
test_multiply_tool.py
- 12 tests covering arithmetic operations, edge cases, error handlingtest_redhat_logo.py
- 10 tests covering async file operations, base64 encoding, error scenariostest_code_review_prompt.py
- 14 tests covering prompt generation, multiple languages, formattingtest_settings.py
- 20 tests covering configuration, environment variables, validationtest_mcp_server.py
- 15 tests covering server initialization, tool registration, error handlingtest_integration.py
- 10 tests covering complete workflows and system integration
Test Features:
✅ Comprehensive error handling validation
✅ Async function testing support
✅ Mock external dependencies
✅ Environment isolation with fixtures
✅ Performance testing for large data
✅ Concurrent usage simulation
✅ Configuration validation testing
Manual Testing
Container testing:
docker-compose up -d curl -f http://localhost:3000/health docker-compose downSSL testing (if configured):
curl -k https://localhost:3000/health
Continuous Integration & Deployment
This project uses GitHub Actions for automated CI/CD workflows to ensure code quality, security, and reliability.
CI/CD Workflows
Workflow | Trigger | Purpose |
CI | Push to main, PRs | Run tests, linting, type checking, security scans |
Dependency Updates | Weekly schedule | Automated dependency updates and security audits |
CI Pipeline Features
✅ Code Quality Assurance:
Multi-Python version testing (3.12, 3.13)
Comprehensive test suite execution (81+ tests)
Code coverage reporting (80%+ requirement)
Ruff linting and formatting validation
MyPy type checking
Docstring validation with pydocstyle
✅ Security & Compliance:
Bandit security linting
Safety dependency vulnerability scanning
✅ Automation & Maintenance:
Dependabot configuration for automated dependency updates
Pre-commit hook automation
Weekly security audits
Automated PR creation for dependency updates
Running CI Checks Locally
Before pushing code, run the same checks that CI runs:
Branch Protection
The main
branch is protected with the following requirements:
All CI checks must pass
Pull request reviews required
Up-to-date branches required
No direct pushes to main
How to Contribute
Development Workflow
Fork and clone:
git fork <repository-url> git clone <your-fork-url> cd template-mcp-serverCreate feature branch:
git checkout -b feature/your-feature-nameSet up development environment:
uv venv source .venv/bin/activate # On Windows: .venv\Scripts\activate uv pip install -e ".[dev]" pre-commit installMake changes following our standards
Run comprehensive testing:
# Code quality ruff check . --fix ruff format . mypy template_mcp_server/ # Tests pytest --cov=template_mcp_server # Pre-commit validation pre-commit run --all-filesCommit and push:
git add . git commit -m "feat: descriptive commit message" git push origin feature/your-feature-nameCreate Pull Request
Coding Standards
Python Style: Follow PEP 8 (enforced by Ruff)
Type Annotations: Required for all public functions and methods
Documentation: Google-style docstrings for all public APIs
Testing: Write tests for new functionality with pytest
Commits: Use conventional commit format (
feat:
,fix:
,docs:
, etc.)Error Handling: Use structured logging and proper exception handling
Adding New MCP Tools
Create tool module:
# template_mcp_server/src/tools/your_tool.py async def your_tool_function(param: str) -> dict: """Your tool description. Args: param: Parameter description. Returns: dict: Result dictionary. """ # Implementation here return {"result": "success"}Register in MCP server:
# In template_mcp_server/src/mcp.py from template_mcp_server.src.tools.your_tool import your_tool_function def _register_mcp_tools(self) -> None: self.mcp.tool()(your_tool_function) # Add this lineAdd tests:
# tests/test_your_tool.py import pytest from template_mcp_server.src.tools.your_tool import your_tool_function @pytest.mark.asyncio async def test_your_tool(): result = await your_tool_function("test_param") assert result["result"] == "success"Update documentation
Adding New Resources
Place assets in:
template_mcp_server/src/tools/assets/
Create resource handler in:
template_mcp_server/src/tools/
Register in:
template_mcp_server/src/mcp.py
Add tests and documentation
Code Review Guidelines
All changes require pull request review
Automated checks must pass (tests, linting, type checking)
Documentation should be updated for user-facing changes
Breaking changes require discussion and versioning consideration
Getting Help
Issues: Open GitHub issues for bugs or feature requests
Discussions: Use GitHub Discussions for questions
Documentation: Check existing docs and code examples
Testing: Provide minimal reproduction cases for bugs
This server cannot be installed
hybrid server
The server is able to function both locally and remotely, depending on the configuration or use case.
A production-ready foundation template for building Model Context Protocol (MCP) servers with FastAPI, featuring modular tools, comprehensive testing, and OpenShift deployment configurations. Includes automated transformation scripts to create custom domain-specific MCP servers.