khalilbenaz/claude-skills-collection/agent-mcp-server-builder

uv init my-mcp-server && cd my-mcp-server
uv add "mcp[cli]"
uv run mcp dev server.py        # hot-reload avec MCP Inspector

npx @modelcontextprotocol/create-server my-mcp-server
cd my-mcp-server && npm install
npm run build

my-mcp-server/
  server.py
  pyproject.toml
  .env               # secrets, jamais committé

from mcp.server.fastmcp import FastMCP
mcp = FastMCP("my-server")
@mcp.tool()
async def ping() -> str:
    """Vérifie que le serveur répond."""
    return "pong"
if __name__ == "__main__":
    mcp.run()          # transport stdio par défaut

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const server = new McpServer({ name: "my-server", version: "1.0.0" });
server.tool("ping", "Vérifie que le serveur répond", {}, async () => ({
  content: [{ type: "text", text: "pong" }],
}));
const transport = new StdioServerTransport();
await server.connect(transport);

from pydantic import BaseModel, Field
class SearchInput(BaseModel):
    query: str = Field(description="Texte à rechercher, supporte la syntaxe Lucene")
    limit: int = Field(default=10, ge=1, le=100, description="Nombre de résultats max")
    since: str | None = Field(default=None, description="Filtre date ISO 8601, ex: 2026-01-01")
@mcp.tool()
async def search_documents(params: SearchInput) -> list[dict]:
    """
    Recherche dans la base documentaire interne.
    Retourne titre, extrait, url et score de pertinence.
    Utiliser quand l'utilisateur cherche un document, une procédure ou une politique.
    """
    results = await db.search(params.query, params.limit, params.since)
    return [{"title": r.title, "snippet": r.snippet, "url": r.url, "score": r.score}
            for r in results]

@mcp.resource("config://app/{env}")
async def get_config(env: str) -> str:
    """Configuration de l'application pour l'environnement donné."""
    if env not in ("dev", "staging", "prod"):
        raise ValueError(f"Environnement inconnu : {env}")
    data = load_config(env)
    return json.dumps(data, indent=2)

@mcp.prompt()
def code_review_prompt(language: str, code: str) -> list[dict]:
    """Template de revue de code réutilisable."""
    return [
        {"role": "user", "content": f"Revois ce code {language} :\n\n```{language}\n{code}\n```\nFocus : sécurité, perf, lisibilité."}
    ]

from mcp.server.fastmcp import FastMCP
import uvicorn
mcp = FastMCP("my-server")
# ... définir tools/resources ...
app = mcp.streamable_http_app()   # renvoie une ASGI app
if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

from mcp.server.fastmcp import Context
from mcp.types import McpError, ErrorCode
@mcp.tool()
async def get_user(user_id: str, ctx: Context) -> dict:
    try:
        user = await db.get_user(user_id)
        if not user:
            raise McpError(ErrorCode.NOT_FOUND, f"Utilisateur {user_id} introuvable")
        return user.dict()
    except DbConnectionError as e:
        await ctx.error(f"DB indisponible : {e}")
        raise McpError(ErrorCode.INTERNAL_ERROR, "Service temporairement indisponible")

# Inspecter interactivement avec MCP Inspector
npx @modelcontextprotocol/inspector python server.py
 
# Tests unitaires (Python)
uv add --dev pytest pytest-asyncio

import pytest
from mcp.client.session import ClientSession
from mcp.client.stdio import StdioServerParameters, stdio_client
@pytest.mark.asyncio
async def test_ping():
    params = StdioServerParameters(command="python", args=["server.py"])
    async with stdio_client(params) as (r, w):
        async with ClientSession(r, w) as session:
            await session.initialize()
            result = await session.call_tool("ping", {})
            assert result.content[0].text == "pong"

{
  "mcpServers": {
    "my-server": {
      "command": "uv",
      "args": ["run", "--directory", "/abs/path/my-mcp-server", "python", "server.py"],
      "env": {
        "API_KEY": "sk-..."
      }
    }
  }
}

{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["dist/index.js"]
    }
  }
}

FROM python:3.12-slim
WORKDIR /app
COPY pyproject.toml .
RUN pip install uv && uv sync --no-dev
COPY . .
EXPOSE 8000
CMD ["uv", "run", "python", "server.py"]

import asyncio
@mcp.tool()
async def slow_api_call(params: MyInput) -> dict:
    try:
        return await asyncio.wait_for(external_api(params), timeout=15.0)
    except asyncio.TimeoutError:
        raise McpError(ErrorCode.INTERNAL_ERROR, "Timeout API après 15s")

import logging, sys
logging.basicConfig(stream=sys.stderr, level=logging.INFO)