Créer un MCP Server de zéro : guide complet du développeur

Un grand modèle de langage, aussi brillant soit-il, ne peut ni interroger votre base de données, ni invoquer vos API internes, ni lire vos fichiers locaux — faute d'un canal d'outillage standardisé. Le Model Context Protocol (MCP), protocole open source d'Anthropic, comble cet écart : Claude, Cursor et GPT accèdent à des capacités externes via une interface unique. Ce guide vous mène de la première ligne de code au déploiement production, en couvrant Tools, Resources, Prompts et le transport HTTP distant — avec une attention particulière à l'écosystème Apple qui alimente les workflows créatifs et techniques.

1. Trois freins : pourquoi l'IA a besoin d'un MCP Server

Avant d'écrire du code, clarifions les problèmes concrets :

1. Îlots d'outils : Function Calling, Plugins, LangChain Tools — chacun son format. Changer de fournisseur de modèle implique de réécrire la couche d'intégration : le classique problème N×M.
2. Données hors de portée : date limite d'entraînement, pas de configuration en temps réel, pas de documentation interne accessible au modèle.
3. Actions impossibles : un chat pur ne peut envoyer de requêtes HTTP, écrire des fichiers ou exécuter du SQL — sans couche d'outils standardisée.

Si vous avez lu notre guide de décision MCP, cet article entre directement dans l'implémentation. Public visé : développeurs backend et ingénieurs IA maîtrisant Python ou TypeScript.

2. Qu'est-ce que MCP : principes et architecture

2.1 Genèse et standardisation

L'intégration d'outils a progressé de Function Calling (format propriétaire OpenAI) aux Plugins (écosystème ChatGPT fermé), jusqu'à MCP (novembre 2024, Anthropic, ouvert). Objectif : une implémentation, plusieurs clients — sous gouvernance AAIF en 2026, avec plus de 10 000 serveurs référencés.

2.2 Architecture : Client ↔ Server ↔ trois capacités

┌────────────────────┐         ┌─────────────────────┐
│   MCP Client       │ ◄─────► │   MCP Server        │
│  (Claude / Cursor) │  JSON   │  (votre développement)│
│                    │  -RPC   │                     │
└────────────────────┘         └─────────────────────┘
                                        │
                          ┌─────────────┼─────────────┐
                          ▼             ▼             ▼
                       Tools       Resources      Prompts
                    (actions)   (lecture données) (modèles)

• Client : côté modèle — Claude Desktop, Cursor, VS Code, agents personnalisés.
• Server : votre couche de capacités — Tools, Resources, Prompts.
• Tools : fonctions exécutables (recherche, calcul, requête base).
• Resources : données en lecture seule, adressées par URI.
• Prompts : gabarits paramétrables pour l'homogénéité des équipes.

2.3 Communication

MCP repose sur JSON-RPC 2.0 :

• stdio : sous-processus local, latence inférieure à 1 ms — idéal pour l'atelier de développement.
• HTTP + SSE / Streamable HTTP : service distant, clients multiples.

Cycle de vie : initialisation → négociation des capacités → requêtes/réponses → fermeture.

2.4 Matrice comparative

3. Environnement de développement et structure de projet

3.1 Choix du langage

• Python (langue principale) : SDK mcp, décorateurs FastMCP.
• TypeScript : SDK @modelcontextprotocol/sdk pour Node et full-stack.

3.2 Installation

python -m venv .venv
source .venv/bin/activate
pip install mcp httpx pydantic

npm init -y
npm install @modelcontextprotocol/sdk

3.3 Structure recommandée

my-mcp-server/
├── server.py
├── tools/
├── resources/
├── prompts/
├── tests/
├── pyproject.toml
└── README.md

3.4 Outils de débogage

• MCP Inspector : interface officielle.
• Claude Desktop : claude_desktop_config.json.
• Cursor : Settings → MCP ou .cursor/mcp.json.

4. Premier MCP Server : Hello World

4.1 Code minimal

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-first-server")

@mcp.tool()
def say_hello(name: str) -> str:
    """Salue une personne"""
    return f"Hello, {name}! Votre premier outil MCP."

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

4.2 Exécution et vérification

python server.py
npx @modelcontextprotocol/inspector python server.py

Dans l'Inspector : tools/list doit retourner say_hello ; tools/call avec {"name": "Développeur"} valide la chaîne complète.

4.3 Connexion Cursor / Claude Desktop

{
  "mcpServers": {
    "my-first-server": {
      "command": "python",
      "args": ["/chemin/absolu/vers/server.py"]
    }
  }
}

5. Tools : fonctions invocables par l'IA

5.1 Signature et documentation

Types, docstring et schéma JSON sont générés automatiquement. Convention : snake_case, verbe en tête.

5.2 Paramètres Pydantic

from pydantic import BaseModel, Field

class SearchInput(BaseModel):
    query: str = Field(description="Terme de recherche")
    max_results: int = Field(default=5)
    language: str = Field(default="fr")

@mcp.tool()
def web_search(input: SearchInput) -> list[dict]:
    """Recherche web structurée"""
    ...

5.3 Cinq outils utiles

1. Calculatrice : sous-ensemble sûr d'évaluation.
2. Fichiers : répertoire autorisé, protection path traversal.
3. HTTP : httpx, timeout 30 s.
4. SQL : SELECT paramétré uniquement.
5. Temps : UTC et fuseaux.

5.4 Outils asynchrones

import httpx

@mcp.tool()
async def fetch_url(url: str) -> str:
    async with httpx.AsyncClient(timeout=30.0) as client:
        response = await client.get(url)
        response.raise_for_status()
        return response.text

6. Resources : contenus dynamiques pour l'IA

6.1 Resource vs Tool

La Resource fournit des données ; le Tool exécute une action. Lecture sans effet de bord — essentiel pour les pipelines créatifs où l'on expose des assets, pas des mutations.

6.2 Exemples

import json

@mcp.resource("config://app-settings")
def get_app_settings() -> str:
    return json.dumps({"version": "1.0", "env": "production"})

@mcp.resource("user://{user_id}/profile")
def get_user_profile(user_id: str) -> str:
    return json.dumps(db.query_user(user_id))

7. Prompts : modèles réutilisables

7.1 Prompts MCP en équipe

Fragments paramétrables pour harmoniser revues de code, briefs créatifs et documentation — particulièrement précieux dans les studios où plusieurs agents Cursor coexistent.

7.2 Exemple revue de code

from mcp.types import PromptMessage, TextContent

@mcp.prompt()
def code_review_prompt(language: str, code: str) -> list[PromptMessage]:
    return [
        PromptMessage(
            role="user",
            content=TextContent(
                type="text",
                text=f"""Revue de code {language} :
1. Lisibilité
2. Sécurité
3. Performance

```{language}
{code}
```"""
            )
        )
    ]

8. Transport HTTP : MCP Server distant

8.1 stdio vs HTTP+SSE

8.2 Implémentation HTTP

mcp = FastMCP("remote-server", transport="streamable-http")
if __name__ == "__main__":
    mcp.run(host="0.0.0.0", port=8000)

8.3 Sécurité

• Bearer Token, liste blanche IP, CORS restreint.
• Limitation de débit : ~10 tools/call/s.

9. Débogage, tests et erreurs courantes

9.1 Workflow Inspector

1. Lancer l'Inspector.
2. Vérifier listes Tools / Resources / Prompts.
3. Tester tools/call et scénarios d'erreur.

9.2 Test unitaire

@pytest.mark.asyncio
async def test_calculator_tool():
    server_params = StdioServerParameters(command="python", args=["server.py"])
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            result = await session.call_tool("calculate", {"expression": "2 + 2"})
            assert result.content[0].text == "4"

9.3 Matrice d'erreurs

10. Production : Docker et observabilité

10.1 Dockerfile

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["python", "server.py"]

10.2 Hébergement 2026

• Railway / Render : 5–20 USD/mois, démarrage rapide.
• Cloud Run : serverless, cold start à anticiper.
• Mac distant Apple Silicon : launchd, écosystème natif pour les créateurs et ingénieurs sur Final Cut, Xcode et Cursor.

10.3 Monitoring

• Journaux structurés par tools/call.
• Métriques Prometheus : P99, taux d'erreur.
• GET /health.

11. Projet pratique : base de connaissances personnelle

11.1 Besoins

• Recherche sémantique dans notes Markdown.
• Création et mise à jour de notes.

11.2 Stack

• ChromaDB ou Qdrant, embeddings OpenAI ou nomic-embed-text.
• watchfiles pour réindexation automatique.

11.3 Outils clés

1. index_notes : indexation vectorielle.
2. search_notes : Top-K sémantique.
3. write_note : écriture contrôlée.
4. notes://{path} : lecture intégrale.

Économie de tokens typique : plus de 90 % par rapport à l'injection brute du corpus.

12. Écosystème MCP et perspectives 2026

12.1 Serveurs recommandés

• mcp-server-filesystem, github, brave-search, postgres, slack.

Documentation : modelcontextprotocol.io.

12.2 Tendances

• Support natif dans Cursor, Claude Desktop, VS Code, Gemini CLI.
• Marketplace MCP, certification AAIF, OAuth 2.1 entreprise.

12.3 Poursuivre

• Lire la spécification complète.
• Publier votre serveur sur GitHub.
• Combiner MCP et agents (Cursor Agent Skills).

13. Conclusion : de l'expérience locale au nœud de production

Ce guide couvre la chaîne complète — du protocole au déploiement Docker, en passant par la base de connaissances vectorielle. MCP s'impose comme le langage commun de l'outillage IA en 2026.

Le mode stdio sur un MacBook portable atteint vite ses limites : fermeture du capot, mémoire partagée entre index vectoriel et applications créatives, concurrence entre plusieurs serveurs. Les workflows exigeants — recherche sémantique, sessions Agent prolongées, outils partagés en studio — gagnent en fluidité sur un Mac Apple Silicon distant, toujours allumé, où la mémoire unifiée accueille embeddings et runtime Python sans compromettre Final Cut ou Xcode.

SFTPMAC propose la location de Mac distants 7×24, pensée pour les MCP Server et pipelines Agent : HTTP+SSE à faible latence, Python/Node natifs, synchronisation SFTP/rsync de vos notes et configurations — une alternative élégante au « Mac personnel comme serveur de production ». Quel outil allez-vous construire en premier ? Hello World suffit pour commencer aujourd'hui.