Créer un MCP Server de zéro :
guide complet pour développeurs

Les LLM raisonnent bien mais exécutent mal. La première réponse fut le Function Calling d'OpenAI (juin 2023) : définir des schémas JSON, laisser le modèle émettre des appels structurés, votre code les exécute. Ça marchait — mais uniquement dans l'API OpenAI. Chaque autre modèle exigeait un adaptateur séparé.

Les Plugins ChatGPT (mars 2023) ont tenté un modèle marketplace : chaque plugin était un wrapper REST sur mesure avec son propre manifeste. La découverte était centralisée dans la boutique OpenAI, pas dynamique au runtime. Quand Anthropic a livré Tool Use et que LangChain a popularisé les frameworks agents, l'industrie avait trois schémas d'outils incompatibles et aucune couche serveur portable.

La logique de conception d'Anthropic rappelle l'USB-C : standardiser le port, pas chaque câble. MCP ne remplace pas les API REST — il les enveloppe derrière une couche uniforme de découverte et d'invocation pour que les clients IA cessent de se soucier du vendor ou du framework de l'autre côté. Au T2 2026, la gouvernance est passée à la Linux Foundation AAIF ; OpenAI, Google et Microsoft livrent tous un support client MCP natif.

MCP repose sur JSON-RPC 2.0 avec messagerie bidirectionnelle. Un Host (Cursor, Claude Desktop) embarque un ou plusieurs MCP Clients. Chaque Client maintient une session 1:1 avec un MCP Server qui fait le pont vers les systèmes réels.

Les Servers exposent trois types de capacités : Tools (actions exécutables avec effets de bord), Resources (données en lecture seule identifiées par URI) et Prompts (modèles de texte réutilisables que le client peut pré-remplir). Les méthodes RPC centrales incluent tools/list, tools/call, resources/list, resources/read, prompts/list et prompts/get.

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "query_database",
    "arguments": { "sql": "SELECT id, email FROM users LIMIT 10" }
  },
  "id": 42
}

Transport STDIO : le Host lance le Server en sous-processus ; les messages circulent sur stdin/stdout. Zéro dépendance réseau, isolation process forte, idéal pour le dev local. Cycle de vie : spawn → handshake initialize → négociation des capacités → session persistante → sortie du sous-processus à la déconnexion.

HTTP + SSE / streamable-http : le Server tourne comme service HTTP longue durée. Le Client ouvre un flux SSE pour les événements server-push ; les appels d'outils passent en POST. Permet déploiement distant, serveurs partagés en équipe, scaling horizontal — mais exige affinité de session pour SSE et auth correcte en edge. La spec 2026 ajoute streamable-http comme transport distant recommandé, remplaçant les patterns SSE-only hérités.

Choisissez votre stack SDK : Python avec mcp + FastMCP pour itérer le plus vite, ou TypeScript avec @modelcontextprotocol/sdk pour des serveurs HTTP natifs Node. Arborescence projet recommandée :

my-mcp-server/
  pyproject.toml
  src/
    server.py          # entrée FastMCP
    tools/             # modules outils
    resources/         # handlers resources
    prompts/           # modèles prompts
  tests/
    test_tools.py
  Dockerfile

Installation : pip install mcp ou npm install @modelcontextprotocol/sdk. Debug avec MCP Inspector (npx @modelcontextprotocol/inspector) — se connecte aux endpoints STDIO ou HTTP et affiche le tools/list en direct. Branchez dans Cursor via Paramètres → MCP → ajouter config serveur ; Claude Desktop via claude_desktop_config.json.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("hello-mcp")

@mcp.tool()
def greet(name: str) -> str:
    return f"Hello, {name}!"

if __name__ == "__main__":
    mcp.run()

Tools avec entrée Pydantic : FastMCP dérive le JSON Schema depuis les type hints et modèles Pydantic automatiquement. Ci-dessous : cinq outils pratiques — calculateur, I/O fichier, requête HTTP, requête DB et horodatage — avec support async et retours d'erreur structurés.

import asyncio
import httpx
from datetime import datetime, timezone
from pathlib import Path
from pydantic import BaseModel, Field
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("utility-server")

class CalcInput(BaseModel):
    expression: str = Field(description="Expression math ex. 2 + 3 * 4")

@mcp.tool()
def calculate(input: CalcInput) -> str:
    try:
        allowed = set("0123456789+-*/(). ")
        if not all(c in allowed for c in input.expression):
            return "Error: invalid characters in expression"
        return str(eval(input.expression, {"__builtins__": {}}, {}))
    except Exception as e:
        return f"Error: {e}"

@mcp.tool()
def read_file(path: str) -> str:
    try:
        target = Path(path).resolve()
        if not target.is_file():
            return f"Error: {path} is not a file"
        return target.read_text(encoding="utf-8", errors="replace")[:50000]
    except Exception as e:
        return f"Error: {e}"

@mcp.tool()
async def http_get(url: str) -> str:
    try:
        async with httpx.AsyncClient(timeout=15.0) as client:
            resp = await client.get(url)
            return resp.text[:10000]
    except Exception as e:
        return f"Error: {e}"

@mcp.tool()
async def db_query(sql: str) -> str:
  try:
    import aiosqlite
    async with aiosqlite.connect("app.db") as db:
      cursor = await db.execute(sql)
      rows = await cursor.fetchall()
      return str(rows[:100])
  except Exception as e:
    return f"Error: {e}"

@mcp.tool()
def current_time(tz: str = "UTC") -> str:
    return datetime.now(timezone.utc).isoformat()

Resources : les URI statiques mappent vers des fichiers fixes ; les URI dynamiques acceptent des paramètres. Un serveur de resources filesystem expose la doc projet que l'agent peut lire sans effets de bord d'outil.

from mcp.server.fastmcp import FastMCP
from pathlib import Path

mcp = FastMCP("fs-resources")
DOCS = Path("./docs")

@mcp.resource("docs://index")
def docs_index() -> str:
    files = [f.name for f in DOCS.glob("*.md")]
    return "\n".join(files)

@mcp.resource("docs://{filename}")
def read_doc(filename: str) -> str:
    path = DOCS / filename
    if not path.exists():
        return f"Error: {filename} not found"
    return path.read_text(encoding="utf-8")

Prompts : modèles réutilisables avec emplacements d'arguments. Un prompt de revue de code pré-remplit le contexte pour que l'agent suive la checklist de votre équipe.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("review-prompts")

@mcp.prompt()
def code_review(file_path: str, language: str) -> str:
    return f"""Review {file_path} ({language}) for:
1. Security vulnerabilities (injection, auth bypass)
2. Performance bottlenecks
3. Error handling gaps
4. Test coverage holes
Provide severity-rated findings with fix suggestions."""

Le transport HTTP streamable est le défaut 2026 pour les MCP Servers distants. Lancez FastMCP avec mcp.run(transport="streamable-http") ou utilisez StreamableHTTPServerTransport du SDK TypeScript. Couchez la sécurité en edge :

Workflow de débogage : MCP Inspector d'abord, puis logs client, puis tests unitaires. Inspector affiche le JSON-RPC brut, les erreurs de validation de schéma et le timing par appel.

import pytest
from server import calculate, CalcInput

def test_calculate_valid():
    result = calculate(CalcInput(expression="2 + 3"))
    assert result == "5"

def test_calculate_invalid_chars():
    result = calculate(CalcInput(expression="import os"))
    assert result.startswith("Error:")

Runbook en six étapes de l'évaluation au MCP Server prêt pour la production :

Chemins production : packagez avec Docker (base python:3.12-slim, utilisateur non-root, health check sur le port HTTP). Options plateforme :

Monitoring : exportez latence requête et compteurs d'appels d'outils vers Prometheus ; envoyez les exceptions à Sentry avec tags nom de méthode MCP. Épinglez les versions SDK dans pyproject.toml / package.json et taguez les images Docker par release — les révisions spec MCP en 2026 apportent encore des changements breaking sur le transport.

Capstone : MCP base de connaissances personnelle. Combinez store vectoriel ChromaDB, modèle d'embedding (Ollama local ou API) et outil de recherche sémantique :

import chromadb
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("knowledge-base")
client = chromadb.PersistentClient(path="./chroma_data")
collection = client.get_or_create_collection("notes")

@mcp.tool()
def semantic_search(query: str, n: int = 5) -> str:
    results = collection.query(query_texts=[query], n_results=n)
    docs = results.get("documents", [[]])[0]
    return "\n---\n".join(docs) if docs else "No matches found."

@mcp.tool()
def ingest_note(text: str, source: str) -> str:
    collection.add(documents=[text], metadatas=[{"source": source}], ids=[source])
    return f"Indexed: {source}"

Serveurs écosystème 2026 à étudier : mcp-server-filesystem (référence officielle), GitHub MCP (ops repo/PR/issue), Brave Search MCP (récupération web), Postgres MCP (SQL avec introspection schéma), Slack MCP (messagerie canal). Tendances S2 2026 : auth OAuth 2.1 standardisée, registres serveurs unifiés, marketplaces MCP multi-tenant hébergées, orchestration Agent-to-Agent (A2A) au-dessus de la couche outils MCP.

Pour les équipes qui font tourner des MCP Servers aux côtés d'agents Cursor, ingestion ChromaDB et CI iOS sur un nœud always-on, la location Mac Mini cloud MESHLAUNCH est en général le meilleur hôte production : Apple Silicon dédié, pas de déconnexion veille, facturation jour/semaine/mois flexible, et un domicile stable où les définitions d'outils deviennent des actifs d'équipe portables au lieu de configs laptop par développeur. Consultez les tarifs pour les specs nœud ; questions réseau et accès dans le centre d'aide.