Introduction au Model Context Protocol (MCP)

Le Model Context Protocol (MCP) est un protocole ouvert conçu pour standardiser la façon dont les applications fournissent du contexte aux grands modèles de langage (LLMs). Pensez au MCP comme un port USB-C pour les applications IA. Tout comme l'USB-C fournit un moyen standardisé de connecter des appareils à divers périphériques, le MCP offre un moyen standardisé de connecter des modèles IA à différentes sources de données et outils.

Pourquoi utiliser MCP ?

Le MCP est particulièrement utile pour construire des agents et des workflows complexes sur les LLMs. Il fournit :

• Une liste croissante d'intégrations pré-construites auxquelles votre LLM peut se connecter directement.
• La flexibilité de changer de fournisseurs et vendeurs de LLM.
• Les meilleures pratiques pour sécuriser vos données au sein de votre infrastructure.

Architecture générale

Le MCP suit une architecture client-serveur où une application hôte peut se connecter à plusieurs serveurs :

• Hôtes MCP : Programmes comme Claude Desktop, IDEs ou outils IA qui veulent accéder aux données via MCP.
• Clients MCP : Clients de protocole qui maintiennent des connexions 1:1 avec les serveurs.
• Serveurs MCP : Programmes légers qui exposent chacun des capacités spécifiques via le Model Context Protocol standardisé.
• Sources de données locales : Les fichiers, bases de données et services de votre ordinateur auxquels les serveurs MCP peuvent accéder de manière sécurisée.
• Services distants : Systèmes externes disponibles sur Internet auxquels les serveurs MCP peuvent se connecter.

Construire un serveur MCP avec TypeScript

Parcourons la construction d'un simple serveur MCP météo en utilisant TypeScript.

Prérequis

• Familiarité avec TypeScript.
• Node.js version 16 ou supérieure installée.

Configuration du projet

D'abord, créez un nouveau répertoire pour votre projet et initialisez-le :

mkdir weather
cd weather
npm init -y

Installez les dépendances nécessaires :

npm install @modelcontextprotocol/sdk zod
npm install -D @types/node typescript

Créez la structure du projet :

mkdir src
touch src/index.ts

Construction du serveur

Commencez par importer les packages nécessaires :

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

Initialisez l'instance du serveur :

const NWS_API_BASE = "https://api.weather.gov";
const USER_AGENT = "weather-app/1.0";
 
const AlertsArgumentsSchema = z.object({
  state: z.string().length(2),
});
 
const ForecastArgumentsSchema = z.object({
  latitude: z.number().min(-90).max(90),
  longitude: z.number().min(-180).max(180),
});
 
const server = new Server(
  {
    name: "weather",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

Implémentez la liste des outils :

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "get-alerts",
        description: "Obtenir les alertes météo pour un état",
        inputSchema: {
          type: "object",
          properties: {
            state: {
              type: "string",
              description: "Code état à deux lettres (ex: CA, NY)",
            },
          },
          required: ["state"],
        },
      },
      {
        name: "get-forecast",
        description: "Obtenir les prévisions météo pour un emplacement",
        inputSchema: {
          type: "object",
          properties: {
            latitude: {
              type: "number",
              description: "Latitude de l'emplacement",
            },
            longitude: {
              type: "number",
              description: "Longitude de l'emplacement",
            },
          },
          required: ["latitude", "longitude"],
        },
      },
    ],
  };
});

Enfin, implémentez la fonction principale pour exécuter le serveur :

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Serveur MCP Weather en cours d'exécution sur stdio");
}
 
main().catch((error) => {
  console.error("Erreur fatale dans main():", error);
  process.exit(1);
});

Conclusion

Le Model Context Protocol (MCP) est un outil puissant pour standardiser l'intégration de modèles IA. En suivant ce guide, vous pouvez construire et utiliser un serveur MCP avec TypeScript, permettant une intégration transparente avec diverses sources de données et outils. Que vous construisiez des workflows complexes ou des applications simples, le MCP fournit la flexibilité et la sécurité nécessaires pour améliorer vos projets IA.

Référence

• Documentation Model Context Protocol
• Auteur : Équipe Model Context Protocol