# Enterprise MCP Server Template

> This repository is an opinionated, production-oriented architecture template for building MCP (Model Context Protocol) servers using Python. It focuses on maintainability, extensibility, and engineering practices rather than implementing domain-specific capabilities.

**This project intentionally contains minimal business logic.**

Its purpose is to demonstrate how to structure production-grade MCP servers. Future repositories extend this template with Linux, Docker, Git, Database, and Kubernetes capabilities.

## Overview
This template provides an enterprise-ready Model Context Protocol (MCP) foundation. It is designed to act as a platform for exposing infrastructure operations to AI agents and clients via a standardized communication protocol.

## Features
- **Opinionated & Architecture-first**: Built around a strict, layered architecture.
- **Capability Registry**: A centralized manager for dynamically loading and registering tools, resources, and prompts.
- **Strict Decoupling**: Business logic is isolated from the server layer and external infrastructure is abstracted via adapters.
- **Production-Ready**: Pre-configured with structured logging (`structlog`), health monitoring, dependency injection, and environment configuration.
- **Dockerized**: Ready for production and local development using Docker and Docker Compose.
- **Fast and Modern**: Built with Python 3.11+ and relies on `uv` for blazing fast package management.

## Roadmap

This repository establishes the canonical architecture that will natively evolve into:

```text
This repository
      ↓
Linux MCP
      ↓
Docker MCP
      ↓
Git MCP
      ↓
Database MCP
      ↓
Redis MCP
      ↓
Kubernetes MCP
```

## Getting Started

### Local Development
```bash
# Start development server
make dev

# Run linting
make lint

# Run formatting
make format

# Run tests
make test
```

### Docker
```bash
# Build development image
make docker

# Run the dockerized server
docker run -it simple-mcp-server:dev
```

## Testing

This repository uses `pytest` and `uv` to manage and run test cases efficiently.

### Running Tests

To run the entire test suite, simply use:
```bash
make test
```
*Note: Under the hood, this runs `uv run pytest`.*

### Test Structure

Tests are organized into logical layers that reflect the enterprise architecture:
- `tests/unit/`: Tests individual components (e.g., `HealthCheck` in `test_health.py`).
- `tests/integration/`: Tests the interactions between capabilities, the registry, and services.
- `tests/e2e/`: End-to-end testing of the fully booted server (Transport to Infrastructure).
- `tests/fixtures/`: Shared test data, mock configurations, and dependency overrides.

### Adding New Tests

When contributing new capabilities, place the corresponding test files in the `tests/unit/` or `tests/integration/` directory using the `test_*.py` naming convention.