sandeep-13-dev/MCP-Server-Template

# Clone the template
git clone [<your-repo-url> my-mcp-server](https://github.com/sandeep-13-dev/MCP-Server-Template.git)
cd my-mcp-server

# Install dependencies
uv sync

SERVER_NAME = "My Awesome MCP Server"
SERVER_VERSION = "1.0.0"
SERVER_DESCRIPTION = "Description of your MCP server"

from fastmcp import FastMCP
from typing import Dict, Any

mcp = FastMCP("My Server")

@mcp.tool
async def my_custom_tool(param: str) -> Dict[str, Any]:
    """Your custom tool implementation"""
    return {"result": f"Processed: {param}"}

# Development mode
python src/server.py

# Or with UV
uv run src/server.py

# Build container
docker-compose build

# Run in production mode
docker-compose up -d

# Check status
docker-compose ps
docker-compose logs -f

# src/tools/my_tools.py
from fastmcp import FastMCP
from typing import Dict, Any, Optional
import asyncio

mcp = FastMCP.get_instance()  # Get shared instance

@mcp.tool
async def process_data(
    data: str, 
    format_type: str = "json",
    timeout: Optional[int] = 30
) -> Dict[str, Any]:
    """
    Process data with specified format.
    
    Args:
        data: Input data to process
        format_type: Output format (json, xml, csv)
        timeout: Processing timeout in seconds
    
    Returns:
        Dict containing processed result
    """
    try:
        # Your processing logic here
        await asyncio.sleep(0.1)  # Simulate async work
        
        return {
            "success": True,
            "result": f"Processed {len(data)} characters as {format_type}",
            "timestamp": "2024-12-26T10:00:00Z"
        }
    except Exception as e:
        return {
            "success": False,
            "error": str(e)
        }

# src/config/settings.py
import os
from typing import Optional

class Settings:
    # Server Configuration
    SERVER_NAME: str = os.getenv("MCP_SERVER_NAME", "MCP Server Template")
    SERVER_VERSION: str = os.getenv("MCP_SERVER_VERSION", "1.0.0")
    SERVER_DESCRIPTION: str = os.getenv("MCP_SERVER_DESCRIPTION", "A template MCP server")
    
    # Network Configuration
    HOST: str = os.getenv("MCP_HOST", "0.0.0.0")
    PORT: int = int(os.getenv("MCP_PORT", "8000"))
    
    # Feature Flags
    ENABLE_HEALTH_CHECK: bool = os.getenv("ENABLE_HEALTH_CHECK", "true").lower() == "true"
    ENABLE_METRICS: bool = os.getenv("ENABLE_METRICS", "false").lower() == "true"
    
    # Security
    API_KEY: Optional[str] = os.getenv("API_KEY")
    CORS_ORIGINS: list = os.getenv("CORS_ORIGINS", "*").split(",")

settings = Settings()

# Optimized for size and security
FROM python:3.11-slim as production

# Non-root user for security
RUN useradd --create-home --shell /bin/bash mcp
USER mcp

# Minimal dependencies
COPY --chown=mcp:mcp . /app
WORKDIR /app

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
    CMD python scripts/healthcheck.py

EXPOSE 8000
CMD ["python", "src/server.py"]

# Linux/macOS
./scripts/build.sh --production --push --tag v1.0.0

# Windows
./scripts/build.cmd --production --push --tag v1.0.0

# Run all tests
uv run pytest

# Run with coverage
uv run pytest --cov=src --cov-report=html

# Run specific test file
uv run pytest tests/test_tools.py

# Run integration tests
uv run pytest tests/test_server.py

# tests/test_tools.py
import pytest
from fastmcp import Client
from src.server import create_server

@pytest.fixture
async def mcp_client():
    """Create a test MCP client."""
    server = create_server()
    client = Client(server)
    async with client:
        yield client

async def test_process_data_tool(mcp_client):
    """Test the process_data tool."""
    result = await mcp_client.call_tool("process_data", {
        "data": "test data",
        "format_type": "json"
    })
    
    assert result[0].text is not None
    data = json.loads(result[0].text)
    assert data["success"] is True
    assert "result" in data

{
  "mcpServers": {
    "my-mcp-server": {
      "transport": "http",
      "url": "http://localhost:8000/mcp",
      "description": "My custom MCP server"
    }
  }
}

{
  "mcpServers": {
    "my-mcp-server": {
      "command": "npx",
      "args": ["mcp-remote", "http://localhost:8000/mcp"]
    }
  }
}

from fastmcp import Client
import asyncio

async def use_mcp_server():
    client = Client("http://localhost:8000/mcp")
    
    async with client:
        # List available tools
        tools = await client.list_tools()
        print(f"Available tools: {[t.name for t in tools]}")
        
        # Use a tool
        result = await client.call_tool("process_data", {
            "data": "Hello, MCP!",
            "format_type": "json"
        })
        print(f"Result: {result[0].text}")

asyncio.run(use_mcp_server())

# src/server.py
from contextlib import asynccontextmanager
from fastmcp import FastMCP

@asynccontextmanager
async def lifespan(app):
    """Manage server lifecycle."""
    print("🚀 Server starting...")
    
    # Startup logic
    await initialize_resources()
    await setup_monitoring()
    
    yield
    
    # Shutdown logic
    await cleanup_resources()
    print("🛑 Server stopped")

def create_server() -> FastMCP:
    """Create and configure the MCP server."""
    mcp = FastMCP(
        name=settings.SERVER_NAME,
        version=settings.SERVER_VERSION,
        description=settings.SERVER_DESCRIPTION
    )
    
    # Import all tools, resources, and prompts
    from src.tools import *
    from src.resources import *
    from src.prompts import *
    
    return mcp

# src/config/auth.py
from fastapi import HTTPException, Security
from fastapi.security.api_key import APIKeyHeader
from src.config.settings import settings

api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)

async def verify_api_key(api_key: str = Security(api_key_header)):
    """Verify API key if authentication is enabled."""
    if settings.API_KEY and api_key != settings.API_KEY:
        raise HTTPException(
            status_code=401,
            detail="Invalid API key"
        )
    return api_key