Comment Créer un Serveur MCP en TypeScript en 30 Minutes

Comment Créer un Serveur MCP en TypeScript en 30 Minutes

Le Model Context Protocol (MCP) est le standard émergent qui permet aux agents IA (Claude, Cursor, GPT-5) d'accéder à vos données et systèmes propriétaires de manière sécurisée et structurée. Si vous avez déjà voulu que votre agent IA puisse consulter votre CRM, votre base de données ou votre documentation interne — c'est exactement ce que MCP rend possible.

Ce tutoriel vous guide pas à pas pour créer votre premier serveur MCP en TypeScript, de l'installation à la connexion dans Cursor.

Pourquoi MCP plutôt qu'une simple API ?

La question légitime : pourquoi ne pas simplement connecter l'agent IA à votre API REST existante ?

La différence fondamentale : MCP est un protocole de découverte d'outils. L'agent IA peut demander à votre serveur MCP "quels outils as-tu disponibles ?" et reçoit une liste structurée avec descriptions, paramètres et types. L'agent comprend alors quoi faire avec ces outils sans configuration manuelle de votre côté.

Avec une API REST classique, vous devez expliquer à l'agent comment l'utiliser dans chaque prompt. Avec MCP, vous le faites une fois dans le code, et tous les agents qui se connectent à votre serveur comprennent automatiquement.

Prérequis

• Node.js 20 ou supérieur
• TypeScript installé globalement : npm install -g typescript
• Un compte CRM ou une base de données (pour l'exemple, on utilisera un CRM simulé)

Étape 1 — Initialisation du projet

mkdir mon-serveur-mcp
cd mon-serveur-mcp
npm init -y
npm install @modelcontextprotocol/sdk express
npm install -D typescript @types/node @types/express ts-node
npx tsc --init

Configurez votre tsconfig.json pour le mode ESM :

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "outDir": "./dist",
    "strict": true,
    "esModuleInterop": true
  }
}

Étape 2 — Créer le serveur MCP de base

// src/index.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";

const server = new Server(
  { name: "mon-crm-mcp", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

// Données simulées CRM
const clients = [
  { id: "1", nom: "Dupont SAS", email: "contact@dupont.fr", pipeline: "Négociation", valeur: 15000 },
  { id: "2", nom: "Martin & Co", email: "info@martin.com", pipeline: "Prospect", valeur: 5000 },
  { id: "3", nom: "Leclerc Digital", email: "bonjour@leclerc.io", pipeline: "Client actif", valeur: 42000 },
];

// Déclaration des outils disponibles
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "recuperer_client",
      description: "Récupère les informations d'un client par son email ou son nom",
      inputSchema: {
        type: "object",
        properties: {
          recherche: { type: "string", description: "Email ou nom du client" }
        },
        required: ["recherche"]
      }
    },
    {
      name: "lister_pipeline",
      description: "Liste tous les clients à une étape du pipeline commercial",
      inputSchema: {
        type: "object",
        properties: {
          etape: { type: "string", description: "Étape du pipeline (Prospect, Négociation, Client actif)" }
        },
        required: ["etape"]
      }
    }
  ]
}));

Étape 3 — Implémenter les handlers d'outils

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  if (name === "recuperer_client") {
    const { recherche } = args as { recherche: string };
    const client = clients.find(c =>
      c.email.includes(recherche) || c.nom.toLowerCase().includes(recherche.toLowerCase())
    );
    if (!client) return { content: [{ type: "text", text: "Aucun client trouvé" }] };
    return {
      content: [{ type: "text", text: JSON.stringify(client, null, 2) }]
    };
  }

  if (name === "lister_pipeline") {
    const { etape } = args as { etape: string };
    const resultats = clients.filter(c => c.pipeline === etape);
    const total = resultats.reduce((sum, c) => sum + c.valeur, 0);
    return {
      content: [{
        type: "text",
        text: JSON.stringify({ clients: resultats, valeur_totale: total }, null, 2)
      }]
    };
  }

  throw new Error("Outil non trouvé : " + name);
});

Étape 4 — Démarrer le transport et connecter à Cursor

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Serveur MCP démarré et en attente de connexions...");
}

main().catch(console.error);

Compilez et testez :

npx tsc && node dist/index.js

Pour connecter à Cursor, ajoutez dans votre ~/.cursor/mcp.json :

{
  "mcpServers": {
    "mon-crm": {
      "command": "node",
      "args": ["/chemin/absolu/vers/dist/index.js"]
    }
  }
}

Étape 5 — Exposer des ressources et des prompts

Les outils ne sont qu'une des trois primitives MCP. Vous pouvez aussi exposer des ressources (données en lecture seule, comme votre wiki interne) et des prompts (templates d'instructions pré-formatés).

// Ressources : votre documentation interne accessible à l'agent
server.setRequestHandler(ListResourcesRequestSchema, async () => ({
  resources: [
    {
      uri: "docs://procedures/onboarding",
      name: "Procédure d'onboarding client",
      description: "Les étapes à suivre pour onboarder un nouveau client",
      mimeType: "text/markdown",
    },
  ],
}));

Étape 6 — Déboguer avec MCP Inspector

MCP Inspector est l'outil officiel de débogage qui vous permet de tester votre serveur sans ouvrir Cursor à chaque fois :

npm install -g @modelcontextprotocol/inspector
mcp-inspector node dist/index.js

L'Inspector ouvre une interface web (localhost:5173) qui affiche la liste de tous vos outils, un formulaire pour tester chaque outil avec des arguments réels, les logs de chaque appel avec la réponse complète, et les erreurs en cas de problème de sérialisation.

Étape 7 — Sécuriser son serveur MCP en production

Un serveur MCP en production sans sécurité est un risque majeur. Les mesures à mettre en place :

• Authentification par Bearer Token : valider un token secret dans chaque requête HTTP
• Rate Limiting : limiter le nombre de requêtes par IP par minute (100 req/min recommandé)
• Logging des accès : logger chaque appel d'outil avec le contexte (timestamp, outil, arguments)
• HTTPS obligatoire : ne jamais exposer un serveur MCP sur Internet sans SSL

Ce que vous pouvez connecter ensuite

Une fois ce serveur MCP de base maîtrisé, les connexions naturelles suivantes sont :

• Votre base PostgreSQL ou MySQL via un pool de connexions
• HubSpot, Salesforce ou Pipedrive via leurs APIs officielles
• Votre documentation Notion ou Confluence pour le RAG interne
• vos pipelines n8n pour déclencher des workflows depuis l'agent IA

---

Vous voulez un serveur MCP personnalisé qui donne à vos agents accès à vos données propriétaires ? BOVO Digital conçoit et livre des serveurs MCP en production.

👉 Parler de votre projet MCP →