MCP Server Cookiecutter Template

🚀 MCP Server Template

This MCP server template is a project that provides a framework for building a server with features such as prompt template management and dialog management. It uses FastAPI as the web framework and includes necessary dependencies and scripts for setup and running.

🚀 Quick Start

1. Install Dependencies

pip install -r requirements.txt

2. Start the Server

make dev
uvicorn run --host 0.0.0.0 --port 8000 mcp.server.fastmcp.cli:create_app

3. Usage Example

Send a request to http://localhost:8000/process:

{
    "data": {
        "input": "Process my data",
        "parameters": {}
    }
}

✨ Features

• Prompt Template Management: Allows listing, creating, updating, and deleting prompt templates.
• Dialog Management: Supports creating, retrieving, updating, and deleting dialogs.

📦 Installation

Install Dependencies

pip install -r requirements.txt

💻 Usage Examples

Basic Usage

Send a request to http://localhost:8000/process:

{
    "data": {
        "input": "Process my data",
        "parameters": {}
    }
}

📚 Documentation

• API Documentation: Open http://localhost:8000/docs in your browser.
• Prompt Template Management: Use the /prompts route.
• Dialog Management: Use the /dialogs route.

🔧 Technical Details

Directory Structure

your-project-name/
├── Makefile
├── README.md
├── setup.py
├── .gitignore
├── pyproject.toml
├── requirements.txt
├── mcp/
│   ├── __init__.py
│   └── server/
│       ├── __init__.py
│       └── fastmcp/
│           ├── __init__.py
│           ├── prompts/
│           │   ├── __init__.py
│           │   └── sample_prompts.py
│           └── dialogs/
│               ├── __init__.py
│               └── sample_dialogs.py

setup.py

from setuptools import setup, find_packages

setup(
    name="your_project_name",
    version="0.1.0",
    packages=find_packages(),
    install_requires=[
        "fastapi",
        "uvicorn",
        "python-multipart",
        "numpy",
        "pandas",
        "langchain",
        "huggingface",
        "tqdm"
    ],
    entry_points={
        "console_scripts": [
            "mcp-server=mcp.server.fastmcp.cli:main",
        ],
    },
)

Makefile

PROJECT_NAME = your-project-name
VENV := .venv

all: clean

setup:
    pip install -r requirements.txt

dev:
    python -m venv $(VENV)
    source $(VENV)/bin/activate  # Unix/MacOS
    set PYTHONPATH=$(PYTHONPATH):$(shell pwd)  # Windows

install:
    pip install -e .

clean:
    find . -name "*.pyc" -delete
    find . -name "__pycache__" -type d -delete

mcp/server/fastmcp/cli.py

import uvicorn
from fastapi import FastAPI
from mcp.server.fastmcp.routers import main_router

def create_app():
    app = FastAPI()
    app.include_router(main_router.router)
    return app

if __name__ == "__main__":
    uvicorn.run("mcp.server.fastmcp.cli:create_app", host="0.0.0.0", port=8000, reload=True)

mcp/server/fastmcp/routers/main.py

from fastapi import APIRouter
from fastapi.responses import JSONResponse
from typing import List, Dict

router = APIRouter()

@router.get("/", response_class=JSONResponse)
async def root():
    return {"message": "MCP server is running"}

@router.post("/process", response_class=JSONResponse)
async def process(data: dict) -> dict:
    # Process data and return results
    return {"status": "success", "result": data}

mcp/server/fastmcp/prompts/base.py

class PromptTemplate:
    def __init__(self, template_str: str):
        self.template = template_str
    
    def format(self, **kwargs) -> str:
        return self.template.format(**kwargs)

mcp/server/fastmcp/dialogs/sample_dialogs.py

from typing import List, Dict, Any
from langchain.schema import Dialogue
from fastapi import APIRouter

dialog_router = APIRouter()

@dialog_router.post("/dialogs", response_class=JSONResponse)
async def create_dialog(request: dict) -> Dict[str, Any]:
    # Create a dialog and return an identifier
    dialog_id = str(uuid.uuid4())
    return {"id": dialog_id}

@dialog_router.get("/dialogs/{dialog_id}", response_class=JSONResponse)
async def get_dialog(dialog_id: str) -> Dict[str, Any]:
    # Get the status of the specified dialog
    pass

@dialog_router.put("/dialogs/{dialog_id}", response_class=JSONResponse)
async def update_dialog(dialog_id: str, data: dict) -> Dict[str, Any]:
    # Update the content of the dialog
    pass

@dialog_router.delete("/dialogs/{dialog_id}", response_class=JSONResponse)
async def delete_dialog(dialog_id: str) -> Dict[str, Any]:
    # Delete the specified dialog
    pass

mcp/server/fastmcp/prompts/sample_prompts.py

from typing import List, Dict, Any
from langchain.prompts import PromptTemplate as LangPromptTemplate
from fastapi import APIRouter

prompt_router = APIRouter()

@prompt_router.get("/prompts", response_class=JSONResponse)
async def list_prompts() -> List[Dict[str, str]]:
    # List all available prompt templates
    pass

@prompt_router.post("/prompts", response_class=JSONResponse)
async def create_prompt(request: dict) -> Dict[str, Any]:
    # Create a new prompt template
    pass

@prompt_router.get("/prompts/{prompt_id}", response_class=JSONResponse)
async def get_prompt(prompt_id: str) -> Dict[str, Any]:
    # Get the detailed information of the specified prompt template
    pass

@prompt_router.put("/prompts/{prompt_id}", response_class=JSONResponse)
async def update_prompt(prompt_id: str, data: dict) -> Dict[str, Any]:
    # Update the content of the specified prompt template
    pass

@prompt_router.delete("/prompts/{prompt_id}", response_class=JSONResponse)
async def delete_prompt(prompt_id: str) -> Dict[str, Any]:
    # Delete the specified prompt template
    pass

Supported Interfaces

1. Prompt Template Management Interface

• /prompts:
  • GET: List all prompt templates.
  • POST: Create a new prompt template.
  • PUT: Update a specified prompt template.
  • DELETE: Delete a specified prompt template.

2. Dialog Management Interface

• /dialogs:
  • POST: Create a new dialog.
  • GET: Get the status of a specified dialog.
  • PUT: Update the content of a specified dialog.
  • DELETE: Delete a specified dialog.

Return Format

{
    "id": "string",          # Unique identifier
    "status": "success" | "error",
    "message": "Operation successful" | "Error message"
}

📄 License

No license information provided.

⚠️ Important Note

Make sure setuptools and wheel are installed before installing dependencies.

💡 Usage Tip

The project uses Python 3.8+. It is recommended to use a virtual environment. All interfaces support JSON format requests and responses.