Guide du protocole MCP 2026 : Connectez l'IA à n'importe quelle source de données

Protocole MCP : la norme universelle pour les intégrations d'IA

Publié : 21 janvier 2026

Tous les agents IA sont confrontés au même problème : ils sont doués pour raisonner mais aveugles à vos données. MCP (Model Context Protocol) résout ce problème en créant un langage universel pour la communication IA-outil.

Si vous avez déjà eu des difficultés avec des intégrations d'API fragmentées, des connecteurs personnalisés ou si vous vous demandez comment donner à votre IA l'accès aux bases de données, aux fichiers ou aux outils internes, MCP est votre réponse.

Points clés à retenir

• MCP est un protocole ouvert qui standardise la manière dont les modèles d'IA se connectent aux sources de données et aux outils externes : pensez à « USB-C pour l'IA ».
• Anthropic, OpenAI, Google et Microsoft prennent tous en charge MCP, ce qui en fait le standard de facto de l'industrie.
• Plus de 13 000 serveurs MCP ont été lancés sur GitHub en 2025, couvrant tout, des bases de données à Slack en passant par les API personnalisées.
• La création d'un serveur MCP nécessite moins de 100 lignes de code et le protocole gère l'authentification, la négociation des capacités et la gestion des erreurs.
• La sécurité nécessite le consentement explicite de l'utilisateur pour toutes les opérations : MCP n'accorde pas un accès général.

Qu’est-ce que le protocole de contexte modèle ?

Model Context Protocol (MCP) est un standard ouvert introduit par Anthropic en novembre 2024. Il fournit une interface universelle aux systèmes d'IA pour :

• Lire les données à partir de fichiers, de bases de données et d'API
• Exécuter des fonctions via des outils définis
• Gérer les invites contextuelles avec des modèles et des flux de travail

Avant MCP, chaque intégration d’IA était un travail personnalisé. Vous souhaitez que Claude accède à votre CRM ? Construisez un connecteur. Besoin de GPT pour interroger votre base de données ? Écrivez un autre connecteur. Chaque fournisseur d'IA, chaque outil : une autre intégration sur mesure.

MCP remplace cette fragmentation par un protocole unique. Créez un serveur MCP pour votre source de données et n'importe quel client AI compatible MCP pourra se connecter.

🔌 MCP est à l'IA ce que LSP (Language Server Protocol) est aux éditeurs de code. Un protocole, une compatibilité universelle.

L'architecture : hôtes, clients et serveurs

MCP utilise un modèle client-serveur simple avec trois rôles :

text
┌─────────────────────────────────────────────────────────┐
│                       HOST                              │
│  (Claude Desktop, ChatGPT, VS Code, Custom App)        │
│                                                         │
│    ┌──────────┐    ┌──────────┐    ┌──────────┐       │
│    │  CLIENT  │    │  CLIENT  │    │  CLIENT  │       │
│    └────┬─────┘    └────┬─────┘    └────┬─────┘       │
└─────────┼───────────────┼───────────────┼─────────────┘
          │               │               │
          ▼               ▼               ▼
    ┌──────────┐    ┌──────────┐    ┌──────────┐
    │  SERVER  │    │  SERVER  │    │  SERVER  │
    │ (Files)  │    │ (Database)│   │ (Slack)  │
    └──────────┘    └──────────┘    └──────────┘

Hôtes

Applications LLM avec lesquelles les utilisateurs interagissent : Claude Desktop, ChatGPT, extensions VS Code ou votre application d'IA personnalisée. Les hôtes établissent des connexions et gèrent l'expérience utilisateur.

Clientèle

Connecteurs de protocole au sein de l’hôte. Chaque client maintient une connexion 1:1 avec un serveur spécifique, gérant la communication JSON-RPC.

Serveurs

Services qui exposent des fonctionnalités aux modèles d'IA. Les serveurs peuvent fournir :

• Ressources : données et contexte (fichiers, enregistrements de base de données, réponses API)
• Outils : fonctions que l'IA peut exécuter (envoyer un e-mail, créer un ticket, interroger une base de données)
• Invites : modèles et flux de travail prédéfinis

Construire votre premier serveur MCP

Créons un simple serveur MCP qui fournit des données météorologiques. Cet exemple utilise le SDK TypeScript officiel.

Étape 1 : configurer le projet

bash
mkdir weather-mcp-server && cd weather-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod

Étape 2 : Créer le serveur

typescript
// server.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";
import { z } from "zod";

// Define the weather tool schema
const GetWeatherSchema = z.object({
  city: z.string().describe("The city to get weather for"),
});

// Create the MCP server
const server = new Server(
  {
    name: "weather-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},  // This server provides tools
    },
  }
);

// Handle tool listing requests
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "get_weather",
        description: "Get current weather for a city",
        inputSchema: {
          type: "object",
          properties: {
            city: { type: "string", description: "City name" },
          },
          required: ["city"],
        },
      },
    ],
  };
});

// Handle tool execution
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "get_weather") {
    const { city } = GetWeatherSchema.parse(request.params.arguments);

    // In production, call a real weather API
    const weather = {
      city,
      temperature: "22°C",
      condition: "Partly cloudy",
      humidity: "65%",
    };

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(weather, null, 2),
        },
      ],
    };
  }

  throw new Error(`Unknown tool: ${request.params.name}`);
});

// Start the server
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Weather MCP server running on stdio");
}

main().catch(console.error);
Collapse

Étape 3 : Configurer pour Claude Desktop

Ajoutez votre serveur au fichier de configuration de Claude Desktop :

json
// ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
// %APPDATA%\Claude\claude_desktop_config.json (Windows)
{
  "mcpServers": {
    "weather": {
      "command": "npx",
      "args": ["ts-node", "/path/to/weather-mcp-server/server.ts"]
    }
  }
}

Redémarrez Claude Desktop et vous pouvez maintenant demander : "Quel temps fait-il à Tokyo ?"

Analyse approfondie des capacités du serveur

Les serveurs MCP peuvent offrir trois types de fonctionnalités :

1. Ressources (exposition des données)

Les ressources permettent aux modèles d'IA de lire les données sans exécuter de code. Parfait pour exposer des fichiers, des enregistrements de base de données ou des réponses API.

typescript
server.setRequestHandler(ListResourcesRequestSchema, async () => {
  return {
    resources: [
      {
        uri: "config://app/settings",
        name: "Application Settings",
        mimeType: "application/json",
      },
    ],
  };
});

server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
  if (request.params.uri === "config://app/settings") {
    return {
      contents: [
        {
          uri: request.params.uri,
          mimeType: "application/json",
          text: JSON.stringify({ theme: "dark", language: "en" }),
        },
      ],
    };
  }
});
Collapse

2. Outils (exécution de fonctions)

Les outils permettent aux modèles d'IA d'agir : envoyer des e-mails, créer des enregistrements, déclencher des flux de travail.

typescript
// Tool that creates a support ticket
{
  name: "create_ticket",
  description: "Create a support ticket in the system",
  inputSchema: {
    type: "object",
    properties: {
      title: { type: "string" },
      description: { type: "string" },
      priority: { type: "string", enum: ["low", "medium", "high"] },
    },
    required: ["title", "description"],
  },
}

3. Invites (modèles de flux de travail)

Les invites fournissent des démarreurs de conversation et des flux de travail prédéfinis.

typescript
server.setRequestHandler(ListPromptsRequestSchema, async () => {
  return {
    prompts: [
      {
        name: "code_review",
        description: "Template for reviewing code changes",
        arguments: [
          { name: "code", description: "The code to review", required: true },
        ],
      },
    ],
  };
});

Fonctionnalités client : l’autre direction

MCP n'est pas seulement une relation serveur-client. Les serveurs peuvent également demander des fonctionnalités aux clients :

Échantillonnage

Les serveurs peuvent demander des complétions LLM via le client, permettant ainsi des interactions récursives d'IA et des comportements agents.

typescript
// Server requests an LLM completion from the client
const result = await client.request({
  method: "sampling/createMessage",
  params: {
    messages: [{ role: "user", content: "Summarize this document..." }],
    maxTokens: 500,
  },
});

Racines

Les serveurs peuvent interroger le client sur les limites d'URI accessibles, ce qui est utile pour comprendre à quels fichiers ou ressources le serveur peut accéder en toute sécurité.

Élicitation

Les serveurs peuvent demander des informations supplémentaires à l'utilisateur via l'interface utilisateur du client, permettant ainsi des flux de travail interactifs.

Couches de transport

MCP prend en charge plusieurs mécanismes de transport :

Pour la plupart des outils locaux, stdio est le transport recommandé. Pour les serveurs MCP hébergés dans le cloud, HTTP avec Server-Sent Events (SSE) offre le meilleur équilibre.

L’écosystème MCP 2025-2026

Adoption par l'industrie

MCP est passé de l'expérience interne d'Anthropic au standard de l'industrie en un temps record :

• Mars 2025 : OpenAI a adopté MCP dans tous les produits ChatGPT
• Avril 2025 : Google DeepMind a confirmé la prise en charge de Gemini
• Mai 2025 : Microsoft et GitHub ont rejoint le comité directeur du MCP
• Novembre 2025 : MCP Apps Extension (SEP-1865) a ajouté des fonctionnalités d'interface utilisateur
• Décembre 2025 : MCP fait un don à l'Agentic AI Foundation de la Linux Foundation

Écosystème de serveurs

Plus de 13 000 serveurs MCP existent désormais sur GitHub :

• Bases de données : PostgreSQL, MySQL, MongoDB, Redis
• Productivité : Slack, Notion, Linear, GitHub
• Cloud : intégrations AWS, GCP et Azure
• Fichiers : système de fichiers local, Google Drive, Dropbox
• Personnalisé : API internes, systèmes propriétaires

Vous pouvez parcourir et installer des serveurs communautaires via le registre MCP officiel.

Sécurité : la couche critique

MCP offre des capacités puissantes, mais le pouvoir exige des responsabilités. Le protocole impose :

Consentement de l'utilisateur

Chaque accès aux données et exécution d’outils nécessite l’approbation explicite de l’utilisateur. Aucune autorisation générale.

typescript
// Clients MUST show this to users before tool execution
{
  tool: "delete_file",
  arguments: { path: "/important/data.csv" },
  requiresConfirmation: true  // User sees and approves
}

Confidentialité des données

• Consentement explicite avant d’exposer des données utilisateur aux serveurs
• Pas de transmission automatique des données
• Contrôles d'accès et journaux d'audit appropriés

Sécurité des outils

Les descriptions d'outils ne sont pas fiables par défaut. Les clients doivent :

• Afficher clairement les capacités de l'outil aux utilisateurs
• Exiger une approbation explicite pour les opérations sensibles
• Consigner tous les appels d'outils pour l'audit

Problèmes de sécurité connus

Les chercheurs en sécurité ont identifié des risques nécessitant des mesures d’atténuation :

1. Injection rapide : des entrées malveillantes pourraient inciter l'IA à lancer des appels d'outils involontaires
2. Tool Shadowing : des outils similaires pourraient remplacer silencieusement ceux de confiance
3. Escalade des autorisations : la combinaison d'outils peut exfiltrer des données

Atténuation : mettez en œuvre des listes d'autorisation d'outils strictes, surveillez les combinaisons d'outils et validez toutes les entrées.

Liste de contrôle de mise en œuvre pratique

Avant de déployer MCP en production :

• Définir la portée : quels outils et ressources votre serveur exposera-t-il ?
• Implémenter l'authentification : utiliser l'authentification appropriée pour les transports HTTP
• Créer des flux de consentement : les utilisateurs doivent approuver toutes les opérations sensibles
• Ajouter une journalisation : suivez tous les appels d'outils et accès aux données
• Test avec MCP Inspector : Déboguer et valider avant le déploiement
• Capacités du document : des descriptions claires aident l'IA à utiliser correctement les outils
• Définir des limites de débit : empêcher les appels d'outils incontrôlables
• Planifier les erreurs : dégradation progressive lorsque les serveurs sont indisponibles

Ce qui arrive en 2026

La feuille de route du MCP comprend :

1. Collaboration multi-agents : escouades d'agents avec des rôles spécialisés (diagnostiquer, corriger, valider, documenter)
2. Capacités améliorées de l'interface utilisateur : l'extension MCP Apps permet des interfaces interactives riches
3. Ressources de streaming : flux de données en temps réel au lieu de requêtes-réponses
4. Identité multiplateforme : authentification unifiée sur les serveurs MCP
5. Optimisations des performances : mécanismes de transport et de mise en cache plus rapides

Conclusion

MCP résout le problème d’intégration qui freinait les agents IA. Au lieu de créer des connecteurs personnalisés pour chaque combinaison d'outils d'IA, vous créez un serveur MCP et bénéficiez d'une compatibilité universelle.

Le protocole est prêt pour la production, largement adopté et soutenu par tous les principaux fournisseurs d’IA. Si vous créez des applications d'IA qui doivent interagir avec des systèmes externes (bases de données, API, fichiers ou outils internes), MCP n'est plus facultatif. C'est la norme.

Prêt à créer votre premier serveur MCP ? Commencez par la documentation officielle et le SDK TypeScript. La courbe d’apprentissage est douce et le résultat est l’intégration universelle de l’IA.

Articles connexes

• Claude AI exécute le code : Python et Node.js en temps réel
• Des chatbots aux agents IA : la révolution tranquille
• [Guide de production des agents IA : éviter les erreurs de 3 400 $] (/blog/ai-agents-production-guide)
• Agentic AI Revolution 2025 : l'avenir est là

Sources

• [Spécification MCP 2025-11-25] (https://modelcontextprotocol.io/specification/2025-11-25)
• [Annonce Anthropic MCP] (https://www.anthropic.com/news/model-context-protocol)
• Dépôt MCP GitHub
• Une année de MCP : Bilan 2025
• Analyse de sécurité MCP - Zenity