Standardisation des intégrations d'IA avec le Model Context Protocol (MCP)
Un guide pratique pour créer et sécuriser des serveurs MCP personnalisés afin de connecter en toute sécurité les données d'entreprise aux agents de développement d'IA.
Connecter des modèles de langage de grande taille (LLM) à des sources de données et à des systèmes internes a historiquement été une tâche fragmentée et ad-hoc. Chaque projet d'ingénierie d'IA commence généralement par l'écriture de wrappers d'API personnalisés, le mappage de schémas JSON ou l'écriture de code d'intégration propriétaire au sein des environnements d'exécution de l'orchestrateur pour gérer les appels d'outils.
Si vous passez d'OpenAI à Anthropic, ou si vos développeurs passent d'un IDE assisté par IA à un autre, vous devez souvent réécrire la couche d'intégration.
Cette friction est la raison pour laquelle le Model Context Protocol (MCP), un standard ouvert mené par Anthropic, a rapidement gagné du terrain. Tout comme le Language Server Protocol (LSP) a standardisé la façon dont les compilateurs communiquent avec les éditeurs de code, le MCP standardise la façon dont les modèles d'IA communiquent avec les sources de données et les outils de développement.
Voici un guide pratique pour créer, structurer et sécuriser un serveur MCP personnalisé afin d'exposer en toute sécurité les données de l'entreprise à vos agents de développement.
L'architecture : découplage des clients et des serveurs
Le principe de conception central du MCP est le découplage. Au lieu de coder en dur les intégrations d'API directement dans l'environnement d'exécution d'un agent, le MCP introduit une architecture client-serveur :
[ AI Agent / IDE ] (MCP Client)
│
│ (JSON-RPC 2.0 over Stdio or SSE)
▼
[ Custom MCP Server ]
│
├─► Secure Database (PostgreSQL / BigQuery)
├─► Internal Microservices
└─► Local Development Tools- Client MCP : Le coordinateur (par exemple, Cursor, Windsurf ou un orchestrateur LangChain personnalisé). Il gère le raisonnement du LLM, conserve le contexte de l'utilisateur et initie les requêtes d'outils.
- Serveur MCP : Un processus ou un service léger qui expose trois primitives fondamentales :
- Prompts : Modèles réutilisables pour guider les interactions du modèle.
- Resources : Sources de données en lecture seule (contenu des fichiers, lignes de base de données, réponses d'API).
- Tools : Fonctions exécutables qui peuvent effectuer des opérations ou appeler des API externes.
Créer un serveur MCP personnalisé en TypeScript
Créons un serveur MCP prêt pour la production en utilisant Node.js et le SDK TypeScript officiel. Ce serveur exposera un outil sécurisé pour rechercher des enregistrements dans une base de données interne (par exemple, des candidats ou des études de cas) avec une validation stricte des arguments à l'exécution.
1. Initialisation du projet
Tout d'abord, configurez un projet TypeScript et installez les dépendances nécessaires :
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install --save-dev typescript @types/node
npx tsc --init2. Implémentation du serveur
Voici le code d'un serveur MCP sécurisé basé sur stdio. Nous enregistrons un outil de recherche et utilisons zod pour appliquer une validation de schéma stricte sur les charges utiles (payloads) entrantes :
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";
// 1. Initialize the MCP Server
const server = new Server(
{
name: "enterprise-search-service",
version: "1.0.0",
},
{
capabilities: {
tools: {}, // Advertise tool capabilities to the client
},
}
);
// 2. Define the Search Schema using Zod
const CandidateSearchSchema = z.object({
query: z.string().min(2),
limit: z.number().optional().default(5),
department: z.enum(["Engineering", "Design", "Product", "Sales"]).optional(),
});
// 3. Register Available Tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [
{
name: "search_candidates",
description: "Search internal database for candidates matching specific skills and departments.",
inputSchema: {
type: "object",
properties: {
query: { type: "string", description: "Search term or required skill" },
limit: { type: "number", description: "Maximum records to return" },
department: { type: "string", enum: ["Engineering", "Design", "Product", "Sales"] },
},
required: ["query"],
},
},
],
};
});
// Mock database resolver
async function queryDatabase(query: string, limit: number, dept?: string) {
// Real implementation would connect to Cloud SQL / BigQuery
return [
{ id: 101, name: "Sarah Connor", role: "Staff Platform Engineer", tags: ["Kubernetes", "Go", "MACH"] },
{ id: 102, name: "Marcus Wright", role: "Solutions Architect", tags: ["Next.js", "React", "AI Agents"] }
];
}
// 4. Handle Tool Executions
server.setRequestHandler(CallToolRequestSchema, async (request) => {
if (request.params.name !== "search_candidates") {
throw new Error(`Tool ${request.params.name} not found`);
}
try {
// Validate the arguments at runtime
const args = CandidateSearchSchema.parse(request.params.arguments);
// Fetch secure records
const results = await queryDatabase(args.query, args.limit, args.department);
return {
content: [
{
type: "text",
text: JSON.stringify(results, null, 2),
},
],
};
} catch (error: any) {
return {
content: [
{
type: "text",
text: `Error validating arguments: ${error.message}`,
},
],
isError: true,
};
}
});
// 5. Start Server Transport (stdio is standard for local IDE integrations)
const transport = new StdioServerTransport();
await server.connect(transport);
console.error("Enterprise Search MCP Server running on stdio");Renforcer la sécurité pour l'usage en entreprise
Bien que l'écriture du code TypeScript soit simple, l'exposition de données de production internes à des LLM nécessite des barrières de sécurité opérationnelles strictes. Les modèles d'IA sont sujets aux hallucinations, aux injections d'instructions (prompts) et aux boucles d'exécution d'outils involontaires.
Voici les quatre piliers de la sécurité MCP en entreprise :
1. Validation de schéma et désinfection des entrées
Ne faites jamais confiance aux arguments générés par un LLM. Validez toujours les paramètres à l'aide de bibliothèques comme Zod, et désinfectez les chaînes de caractères pour éviter les risques sur la base de données :
- Utilisez des requêtes paramétrées ou des ORM pour empêcher les injections SQL.
- Validez les chemins de répertoires pour empêcher les failles de traversée de répertoires si votre outil lit des fichiers locaux.
2. Authentification et transmission du contexte OAuth
Lors de l'exécution dans un réseau d'entreprise, vous devez vérifier le niveau d'autorisation de l'utilisateur derrière l'agent.
- Exposez le MCP via des Server-Sent Events (SSE) plutôt que stdio. Cela permet d'exécuter le serveur MCP en tant que microservice indépendant derrière une passerelle d'API.
- Transmettez le jeton d'identité de l'utilisateur (JWT) dans les en-têtes de requête, permettant à votre serveur MCP d'appliquer la sécurité au niveau des lignes (RLS) dans la base de données cible.
3. Contrôle avec intervention humaine (HITL)
L'exposition d'outils de lecture (comme search_candidates) présente un faible risque. Cependant, l'exposition d'outils d'écriture (comme update_records ou deploy_service) est dangereuse.
- Mettez en œuvre des approbations explicites pour les actions d'écriture. Le client MCP doit intercepter les requêtes d'écriture et présenter au développeur un diff montrant les modifications que l'agent souhaite appliquer.
[ Agent Tool Request ] ──► [ Security Middleware ] ──► (Diff Check / UI Popup)
│
┌──────────────────────────────────────────┘
▼
[ User Approves? ] ──(Yes)──► [ Execute Write on Server ]4. Limitation du débit et garde-fous
Les agents peuvent entrer dans des boucles de raisonnement récursives où ils appellent un outil des dizaines de fois en quelques secondes, ce qui entraîne des charges de base de données importantes ou des coûts de jetons élevés.
- Appliquez une limitation du débit de requêtes par session.
- Limitez la taille maximale des charges utiles de résultats pour éviter le dépassement de jetons.
Perspectives : Exposer les systèmes existants comme des primitives d'IA
La force du Model Context Protocol est qu'il transforme les interfaces logicielles existantes en fonctionnalités propres et détectables.
En encapsulant les bases de données internes, les scripts de déploiement et les API dans une couche MCP standardisée, vous vous assurez que tout outil d'IA (qu'il s'agisse d'un éditeur comme Cursor, d'un compagnon de terminal ou d'un agent de déploiement autonome) peut interagir avec votre logique métier de manière sécurisée, prévisible et sans surcoût de traduction.