Protocole MCP : connecter vos agents IA à tous vos outils métier

Qu'est-ce que le protocole MCP ?

Le Model Context Protocol (MCP) est une spécification open source publiée par Anthropic en novembre 2024. Son objectif : créer un standard universel pour que les modèles de langage (LLMs) puissent interagir de façon fiable et sécurisée avec des outils, des bases de données et des APIs externes.

Avant MCP, chaque intégration entre un agent IA et un outil externe était une solution propriétaire : les plugins OpenAI, les function calls avec leurs propres formats JSON, les intégrations Zapier… Chaque fournisseur avait sa propre façon de faire. Résultat : des intégrations fragiles, non portables, difficiles à maintenir.

Concrètement, MCP définit comment :

• Un agent IA (client MCP) découvre les outils disponibles
• Un serveur MCP expose ces outils avec leurs descriptions et paramètres
• Les appels d'outils sont transmis et les résultats retournés
• Les ressources (fichiers, données) sont accessibles en lecture
• Les prompts préconfigurés sont partagés entre serveur et client

L'adoption de MCP a été très rapide. Des acteurs majeurs comme Block (Square), Apollo, Sourcegraph, et des dizaines d'éditeurs de logiciels métier ont publié leurs serveurs MCP. Pour une PME française, cela signifie qu'il existe probablement déjà un serveur MCP pour vos outils principaux : Salesforce, HubSpot, Notion, GitHub, PostgreSQL, Google Drive, Slack…

Architecture MCP : client, serveur, ressources

Comprendre l'architecture MCP est indispensable avant toute configuration. Le protocole repose sur trois composantes qui communiquent selon un schéma client-serveur classique.

Le client MCP — l'agent qui pose les questions

Le client MCP est l'application qui héberge le LLM et qui a besoin d'utiliser des outils externes. Exemples concrets :

• Claude Desktop : l'application de bureau d'Anthropic, premier client MCP grand public
• Cursor : l'éditeur de code IA qui utilise MCP pour les outils de développement
• Votre application custom : toute app que vous développez avec le SDK MCP client (Node.js, Python, Go)
• N8N : via le nœud MCP disponible depuis N8N 1.x

Le serveur MCP — le pont vers vos outils

Le serveur MCP est un processus qui expose des capacités au client. Il peut être :

• Local (stdio) : s'exécute sur la même machine que le client, communication via stdin/stdout. Simple, sécurisé, adapté pour le développement et les déploiements mono-utilisateur.
• Distant (SSE/HTTP) : s'exécute sur un serveur, communication via Server-Sent Events ou HTTP. Adapté pour les déploiements multi-utilisateurs et les intégrations cloud.

Les trois types de ressources MCP

Le flux de communication MCP

Voici ce qui se passe quand un utilisateur pose une question à un agent IA connecté via MCP :

1. L'utilisateur envoie une requête au client MCP (ex : "Crée une opportunité dans notre CRM pour le prospect Dupont SA")
2. Le client MCP interroge les serveurs MCP connectés pour découvrir les outils disponibles
3. Le LLM décide quel outil appeler et avec quels paramètres (ex : outil create_opportunity avec name="Dupont SA")
4. Le client envoie l'appel d'outil au serveur MCP via le protocole standardisé
5. Le serveur MCP exécute l'action (appel API CRM) et retourne le résultat
6. Le LLM intègre le résultat dans sa réponse finale à l'utilisateur

Cas d'usage MCP concrets pour les PME

Avant d'entrer dans la technique, voici les cas d'usage MCP les plus rentables pour une PME française :

Étape 1 — Installer un serveur MCP

La plupart des serveurs MCP sont distribués via npm (Node.js) ou PyPI (Python). La procédure d'installation est standardisée.

Prérequis techniques

• Node.js 18+ (recommandé : LTS 22.x) ou Python 3.10+ selon le serveur MCP
• Accès terminal / ligne de commande
• Clés API des outils à connecter (ex : clé API HubSpot, token GitHub…)

Exemple : installer le serveur MCP filesystem

Le serveur MCP filesystem est le plus simple pour commencer — il permet à l'agent IA de lire et écrire des fichiers dans un répertoire que vous définissez.

npx @modelcontextprotocol/server-filesystem /chemin/vers/votre/dossier

Exemple : installer le serveur MCP PostgreSQL

npm install -g @modelcontextprotocol/server-postgres

Puis, lancer le serveur avec la chaîne de connexion à votre base :

mcp-server-postgres postgresql://user:password@localhost/ma_base

Serveurs MCP disponibles pour les outils courants des PME françaises

• HubSpot CRM : @hubspot/mcp-server (officiel HubSpot)
• Notion : @notionhq/mcp-server (officiel Notion)
• GitHub : @modelcontextprotocol/server-github (officiel Anthropic)
• Google Drive : @modelcontextprotocol/server-gdrive
• Slack : @modelcontextprotocol/server-slack
• PostgreSQL : @modelcontextprotocol/server-postgres
• MySQL : serveurs communautaires disponibles sur GitHub
• Brave Search : @modelcontextprotocol/server-brave-search (recherche web)

Étape 2 — Configurer les outils disponibles

Une fois le serveur MCP installé, vous devez configurer quels outils il expose à l'agent IA. Cette configuration est au cœur de la sécurité MCP : vous définissez précisément ce que l'agent peut et ne peut pas faire.

Structure d'un outil MCP

Chaque outil MCP est décrit par :

• name : identifiant de l'outil (ex : create_contact)
• description : texte en langage naturel expliquant à quoi sert l'outil — c'est ce que le LLM lit pour décider si il doit l'appeler
• inputSchema : les paramètres acceptés (format JSON Schema)

Exemple de configuration Claude Desktop (fichier claude_desktop_config.json)

Sur macOS, le fichier est dans ~/Library/Application Support/Claude/claude_desktop_config.json. Sur Windows : %APPDATA%/Claude/claude_desktop_config.json.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/maxime/Documents/clients"],
      "env": {}
    },
    "hubspot": {
      "command": "npx",
      "args": ["-y", "@hubspot/mcp-server"],
      "env": {
        "HUBSPOT_API_KEY": "votre_cle_api_hubspot"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost/ma_base"],
      "env": {}
    }
  }
}

Principe du moindre privilège

Configurez chaque serveur MCP avec les permissions minimales nécessaires :

• Pour le serveur filesystem : limitez le chemin d'accès au strict minimum nécessaire
• Pour les APIs : utilisez des clés API avec des scopes restreints (lecture seule si l'agent n'a besoin que de lire)
• Pour les bases de données : créez un utilisateur PostgreSQL dédié avec uniquement les droits SELECT, INSERT nécessaires

Étape 3 — Connecter l'agent IA au serveur MCP

Via Claude Desktop (solution no-code)

Pour la majorité des PME, Claude Desktop est le point d'entrée le plus simple. Une fois le fichier claude_desktop_config.json configuré :

1. Redémarrez Claude Desktop
2. En bas à gauche de l'interface, une icône "outils" apparaît si des serveurs MCP sont connectés
3. Cliquez dessus pour voir la liste des outils disponibles
4. Testez en posant une question qui devrait déclencher un outil : "Liste les 5 derniers contacts créés dans notre CRM"

Via un agent IA custom (Node.js SDK)

Pour intégrer MCP dans votre propre application, utilisez le SDK client officiel :

npm install @modelcontextprotocol/sdk

Connexion à un serveur MCP local en stdio :

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "npx",
  args: ["-y", "@modelcontextprotocol/server-filesystem", "/data/clients"]
});

const client = new Client({
  name: "mon-agent-pme",
  version: "1.0.0"
}, { capabilities: {} });

await client.connect(transport);

// Découvrir les outils disponibles
const { tools } = await client.listTools();
console.log("Outils disponibles :", tools.map(t => t.name));

// Appeler un outil
const result = await client.callTool({
  name: "read_file",
  arguments: { path: "/data/clients/dupont-sa.txt" }
});

Étape 4 — Tester en profondeur

La phase de test MCP est souvent sous-estimée. Un agent IA avec des outils MCP peut faire des actions réelles (écrire dans une base, envoyer des emails, modifier des fichiers). Testez exhaustivement avant de mettre en production.

Matrice de tests recommandée

Outil de debug MCP

Anthropic fournit un inspecteur MCP officiel pour déboguer les échanges entre client et serveur :

npx @modelcontextprotocol/inspector npx @modelcontextprotocol/server-filesystem /votre/dossier

Cet outil affiche une interface web sur localhost:5173 qui permet de lister les outils, les appeler manuellement et inspecter les échanges de messages JSON-RPC. Indispensable pour le développement.

Étape 5 — Déployer en production

Pour un déploiement en production multi-utilisateurs, le serveur MCP doit être hébergé sur une infrastructure stable et accessible.

Option 1 : Déploiement Docker (recommandé pour les PME)

Exemple de Dockerfile pour un serveur MCP Node.js :

FROM node:22-alpine
WORKDIR /app
RUN npm install -g @modelcontextprotocol/server-filesystem
ENV MCP_PATH=/data/documents
CMD ["mcp-server-filesystem", "/data/documents"]

Dans votre docker-compose.yml :

services:
  mcp-filesystem:
    build: ./mcp-filesystem
    volumes:
      - ./documents:/data/documents:ro
    restart: unless-stopped
    ports:
      - "127.0.0.1:3001:3001"

Option 2 : Serveur MCP distant via SSE

Pour les déploiements multi-utilisateurs, le transport SSE (Server-Sent Events) permet à plusieurs clients MCP de se connecter simultanément au même serveur. La configuration côté client devient :

{
  "mcpServers": {
    "mon-serveur-distant": {
      "url": "https://mcp.votre-entreprise.fr/sse",
      "headers": {
        "Authorization": "Bearer votre-token-secret"
      }
    }
  }
}

Étape 6 — Monitorer et maintenir

Un serveur MCP en production doit être supervisé comme tout service critique de votre infrastructure.

Métriques à surveiller

• Taux d'erreur des appels d'outils : objectif < 1% d'erreurs non-intentionnelles
• Latence des outils : un outil qui met > 5 secondes dégrade significativement l'expérience
• Volume d'appels par outil : identifier les outils les plus utilisés et ceux jamais appelés (descriptions à améliorer)
• Erreurs de transport : déconnexions, timeouts, erreurs JSON-RPC

Logging des appels MCP

Loggez systématiquement tous les appels d'outils : qui a demandé quoi, quand, avec quels paramètres, quel résultat. Ces logs sont précieux pour :

• Débogage en cas d'incident
• Audit de sécurité (qui a accédé à quelles données)
• Optimisation des descriptions d'outils (identifier les appels incorrects)
• Conformité RGPD si les outils traitent des données personnelles

MCP vs alternatives : function calling, plugins, RAG

MCP n'est pas la seule façon de connecter un LLM à des outils. Voici une comparaison honnête avec les alternatives :

La combinaison MCP + N8N est souvent la plus pertinente pour les PME avancées : N8N expose ses workflows comme outils MCP, et l'agent IA décide intelligemment quels workflows déclencher selon le contexte.

Erreurs courantes et solutions

1. Le client MCP ne trouve pas le serveur

Symptôme : Message "Server not found" ou aucun outil affiché dans Claude Desktop.

Causes fréquentes : Chemin d'accès incorrect dans la config, serveur non démarré, erreur JSON dans le fichier de config.

Solution : Validez le JSON de config (node -e "JSON.parse(require('fs').readFileSync('config.json','utf8'))"), testez le serveur directement en ligne de commande avant de le configurer dans Claude Desktop.

2. L'agent n'appelle jamais un outil pourtant disponible

Symptôme : L'agent répond par une hallucination au lieu d'utiliser l'outil approprié.

Cause : Description de l'outil trop vague ou ambiguë, ou conflit entre plusieurs outils avec des descriptions similaires.

Solution : Réécrire la description de l'outil avec des mots-clés précis sur les cas d'usage. Éviter les descriptions génériques comme "useful for managing data".

3. Erreurs de permissions sur le filesystem

Symptôme : Erreur "Permission denied" quand l'agent tente de lire/écrire un fichier.

Solution : Vérifiez que le processus qui exécute le serveur MCP a les droits lecture/écriture sur le répertoire configuré. Sur Linux/macOS : chmod 755 /votre/dossier.

4. Timeouts sur les outils lents

Symptôme : L'agent abandonne l'appel avant que l'outil ait répondu.

Solution : Le timeout par défaut côté client MCP est souvent de 30 secondes. Pour les outils lents (rapports, exports volumineux), configurez un timeout plus long côté client, ou découpez l'opération en étapes plus rapides.

Glossaire MCP

Les termes spécifiques au protocole MCP expliqués simplement.

MCP (Model Context Protocol)

Protocole open source standardisant la communication entre les modèles de langage (LLMs) et les outils/ressources externes. Créé par Anthropic, maintenu par la communauté. Spécification disponible sur modelcontextprotocol.io.

Client MCP

L'application qui héberge le LLM et qui se connecte aux serveurs MCP pour accéder aux outils. Exemples : Claude Desktop, Cursor, votre application custom utilisant le SDK MCP.

Serveur MCP

Le processus qui expose des outils, ressources et prompts au client MCP. Il fait le pont entre le protocole MCP et les systèmes réels (APIs, bases de données, fichiers).

Tool (outil MCP)

Une fonction que l'agent IA peut appeler pour effectuer une action : lire un fichier, créer un contact CRM, requêter une base de données. Chaque outil a un nom, une description et un schéma de paramètres.

Resource (ressource MCP)

Une donnée en lecture que l'agent IA peut consulter : contenu d'un fichier, liste d'entrées d'une base. Contrairement aux tools, les ressources ne déclenchent pas d'actions.

Prompt (MCP)

Un template de prompt préconfigurés par le serveur MCP. Permet au serveur de proposer des façons standardisées d'interagir avec ses outils.

Transport stdio

Mode de communication où le client et le serveur MCP s'exécutent sur la même machine et échangent via stdin/stdout. Simple, sécurisé, idéal pour les déploiements mono-machine.

Transport SSE (Server-Sent Events)

Mode de communication réseau pour les serveurs MCP distants. Permet à plusieurs clients de se connecter simultanément au même serveur MCP via HTTP.

JSON-RPC

Le format de messages utilisé par MCP pour les échanges entre client et serveur. Un standard léger basé sur JSON pour les appels de procédures à distance.

Tool chaining

Lorsque l'agent IA appelle plusieurs outils MCP en séquence, en utilisant le résultat du premier comme entrée du second. Permet de réaliser des tâches complexes multi-étapes.