Technical Tutorials

Dans le paysage en pleine évolution de l'Intelligence Artificielle, les grands modèles de langage (LLM) sont puissants mais souvent isolés. Ils s'appuient sur des connaissances pré-entraînées ou un contexte injecté via des prompts, ce qui peut être limité, statique ou coûteux en jetons. Le protocole de contexte de modèle (MCP) est apparu comme la norme pour résoudre ce problème. Développé par Anthropic, le MCP est une norme ouverte qui permet aux applications LLM de se connecter en toute sécurité à des sources de données externes, des outils et des environnements.

Pensez au MCP comme au "USB-C de l'IA". Tout comme l'USB-C fournit une interface universelle pour la recharge et le transfert de données entre différents appareils, le MCP fournit une interface universelle pour que les LLM interagissent avec le monde numérique. Dans ce guide, nous explorerons l'architecture du MCP et démontrerons comment construire un serveur MCP robuste à partir de zéro.

Comprendre l'architecture du MCP

Le MCP fonctionne sur une architecture client-serveur. L'hôte MCP (tel que Claude Desktop ou une application personnalisée) initie la connexion. Il contient un client MCP qui communique avec un ou plusieurs serveurs MCP. Ces serveurs agissent comme des passerelles, exposant des capacités spécifiques (outils) ou des données (ressources) au LLM dans un format structuré et conforme à JSON-RPC.

L'avantage clé de ce découplage est la sécurité et la modularité. Le LLM lui-même n'exécute pas de code arbitraire ni n'effectue d'appels d'API directs vers des services tiers. Au lieu de cela, il demande des actions spécifiques définies par le serveur MCP, qui exécute ensuite l'action dans un environnement isolé et renvoie le résultat.

Définir les capacités : Outils vs Ressources

Lors de la construction d'un serveur MCP, vous devez décider ce que vous exposez. Généralement, cela se divise en deux catégories :

Outils : Des fonctions que le LLM peut exécuter. Par exemple, "get_current_weather" ou "create_github_issue". Ce sont des actions étatiques qui modifient le monde ou récupèrent des données fraîches.
Ressources : Des structures de données en lecture seule que le LLM peut récupérer. Par exemple, un chemin de système de fichiers ou un schéma de table de base de données spécifique. Elles sont généralement utilisées pour fournir un contexte sans nécessiter d'appel de fonction.

Construire un serveur MCP simple en TypeScript

Pour cet exemple, nous utiliserons le SDK TypeScript officiel du MCP pour construire un serveur qui expose un simple outil "Calculatrice". Ce serveur permet au LLM d'effectuer des opérations arithmétiques de base.

D'abord, installez les dépendances nécessaires :


npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript ts-node

Maintenant, créons notre fichier serveur, server.ts. Nous définirons l'outil en utilisant zod pour la validation du schéma, garantissant que les paramètres d'entrée sont strictement typés.


import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// Initialiser le serveur MCP
const server = new McpServer({
  name: "calculator-server",
  version: "1.0.0",
});

// Définir un Outil : Calculate
server.tool(
  "calculate",
  {
    expression: z
      .string()
      .describe("Une expression mathématique à évaluer, par ex. '2 + 2'"),
  },
  async ({ expression }) => {
    try {
      // Vérification de sécurité simple : N'autoriser que les opérateurs de base
      if (!/^[\d+\-*/(). ]+$/.test(expression)) {
        return {
          content: [{ type: "text", text: "Caractères invalides dans l'expression." }],
        };
      }

      // Note : Dans un environnement de production, utilisez une bibliothèque d'analyse mathématique sûre.
      // N'utilisez PAS eval() directement sur les entrées utilisateur.
      const result = new Function(`return ${expression}`)();
      
      return {
        content: [{ type: "text", text: `Résultat : ${result}` }],
      };
    } catch (error) {
      return {
        content: [{ type: "text", text: `Erreur : ${error.message}` }],
        isError: true,
      };
    }
  }
);

// Définir une Ressource : Horodatage actuel
server.resource(
  "current-time",
  "time://now",
  { title: "Heure actuelle du serveur" },
  async (uri) => {
    return {
      contents: [
        {
          uri: uri.toString(),
          text: new Date().toISOString(),
        },
      ],
    };
  }
);

// Exécuter le serveur
const transport = new StdioServerTransport();
server.connect(transport).catch(console.error);

Détails d'implémentation clés

Remarquez l'utilisation de zod dans la définition de l'outil. Le MCP s'appuie fortement sur JSON Schema pour décrire ce qu'un outil attend. La méthode describe est cruciale car elle fournit des métadonnées au LLM. Si votre description est vague, le LLM peut halluciner des entrées invalides ou ne pas comprendre quand utiliser l'outil. La précision dans la rédaction des descriptions est une compétence critique pour les développeurs MCP.

De plus, la gestion des erreurs est explicite. En définissant isError: true, vous informez le client MCP (et donc le LLM) que l'exécution de l'outil a échoué. Cela permet au LLM de potentiellement réessayer avec des arguments différents ou d'informer l'utilisateur de l'échec de manière élégante.

Connexion à Claude Desktop

Pour tester votre serveur, vous devez configurer votre hôte MCP. Pour Claude Desktop, vous modifiez le fichier claude_desktop_config.json (situé dans ~/Library/Application Support/Claude/ sur macOS ou %APPDATA%\Claude sur Windows).


{
  "mcpServers": {
    "calculator": {
      "command": "npx",
      "args": ["ts-node", "/chemin/vers/votre/server.ts"]
    }
  }
}

Redémarrez Claude Desktop. Vous devriez maintenant voir l'outil "Calculatrice" disponible dans le menu développeur ou directement utilisable dans le chat. Demandez à Claude de "calculer 15 * 3" et regardez-le invoquer votre serveur en arrière-plan.

Meilleures pratiques et considérations de sécurité

Privilèges minimaux : Votre serveur MCP ne devrait exposer que les capacités minimales nécessaires. Si vous construisez un connecteur de base de données, n'exposez pas l'exécution SQL brute si vous pouvez l'éviter. Fournissez des fonctions spécifiques et sûres comme getUserById.
Validation des entrées : Validez toujours les entrées. Même si le LLM génère l'entrée, il peut faire des erreurs. Utilisez la validation de schéma (comme Zod) pour rejeter les données malformées avant qu'elles n'atteignent votre logique backend.
Idempotence : Dans la mesure du possible, concevez des outils pour qu'ils soient idempotents. Si un outil échoue en cours de route, le LLM pourrait réessayer. Assurez-vous que les nouvelles tentatives ne provoquent pas d'effets secondaires comme des facturations en double ou la corruption de données.
Journalisation : Implémentez une journalisation détaillée dans votre serveur. Lorsque le LLM a du mal à utiliser un outil, les journaux fourniront des informations sur les paramètres transmis et la raison pour laquelle l'appel a peut-être échoué.

Directions futures

Le MCP est encore un protocole jeune. À mesure qu'il mûrit, attendez-vous à voir :

Normes d'authentification : Des flux OAuth2 plus robustes intégrés directement dans la spécification du protocole pour un accès sécurisé aux API protégées.
Ressources streamables : Un meilleur support pour les flux de données en temps réel, permettant aux LLM de surveiller des sources de données en direct comme les cotes boursières ou les journaux de serveur.
Orchestration multi-serveurs : Des capacités améliorées pour que les hôtes gèrent des dizaines de serveurs MCP simultanément, avec un routage intelligent pour éviter l'enflure de la fenêtre de contexte.

Conclusion

Construire des serveurs MCP n'est plus seulement un exercice théorique ; cela devient la méthode standard pour étendre les capacités des applications d'IA. En découplant la logique du modèle, vous créez des systèmes plus sûrs, maintenables et polyvalents. Que vous construisiez un simple lecteur de fichiers ou un connecteur de données d'entreprise complexe, le MCP fournit les fondations dont vous avez besoin.

Commencez petit. Construisez un seul outil qui résout un problème spécifique dans votre flux de travail. Testez-le soigneusement. Puis, étendez. L'écosystème se développe rapidement, et les premiers adoptants constatent déjà des améliorations significatives dans la capacité de leurs applications LLM à raisonner et à agir dans leurs environnements spécifiques.