Aller au contenu

Serveurs MCP : brancher un agent sur vos outils sans lui ouvrir toutes les portes

Un serveur MCP donne à un agent IA l’accès à un outil : messagerie, tickets, code, base de données. Les failles déjà publiées, la checklist avant d’ajouter un serveur tiers, le squelette d’un serveur interne qui demande confirmation avant d’écrire, et les règles qu’on a posées sur nos propres outils.

Par Publié le 2 octobre 2026Mis à jour le 26 octobre 2026

Serveur MCP : où vivent le jeton et le journalEn local, il hérite des droits du poste ; à distance, il n’accepte que les jetons émis pour lui.

Serveur local

  1. L’application d’IA

  2. Le serveur MCP

    Lancé sur le poste

  3. L’outil

  • Le jeton : dans l’environnement du poste
  • Le journal : sur chaque poste, quand il existe
  • Une faille compromet le poste et ses secrets

Serveur distant

  1. L’application d’IA

  2. Le serveur MCP

    Partagé, sur le web

  3. L’outil

  • Le jeton : émis pour ce serveur, qui refuse tout autre
  • Le journal : au même endroit pour tous
  • Une faille reste bornée par ses jetons

Pour une équipe : des serveurs distants, publiés dans un catalogue interne validé

Un serveur MCP est un programme qui donne à un agent IA l’accès à un outil : votre messagerie, vos tickets, un dépôt de code, une base de données. MCP (Model Context Protocol) est le standard ouvert qui fixe la façon dont les applications d’IA et ces serveurs se parlent. Brancher un serveur est simple, et c’est précisément pour cela qu’il faut décider avant ce que l’agent pourra faire.

Anthropic a publié MCP en novembre 2024 ; depuis décembre 2025, il est maintenu par l’Agentic AI Foundation, rattachée à la Linux Foundation, et la version de la spécification en vigueur date du 28 juillet 2026. Cet article donne la checklist qu’on passe avant d’ajouter un serveur tiers, le squelette d’un serveur interne, et les règles posées sur nos propres outils.

Ce qu’un serveur MCP donne vraiment à l’agent

Un serveur expose surtout des outils, c’est-à-dire des actions que l’agent peut déclencher (envoyer un message, créer un ticket, modifier un fichier), et des ressources, des données qu’il peut lire. Ce sont les outils qui portent le risque : chacun est une action réelle, exécutée avec les droits du jeton que le serveur détient.

Les failles déjà publiées

  • Avril 2025, des instructions cachées dans les outils. Invariant Labs décrit l’empoisonnement des outils (tool poisoning) : des consignes glissées dans la description d’un outil, invisibles pour la personne, lues par le modèle.
  • Mai 2025, un ticket piégé. La même équipe montre qu’un ticket malveillant dans un dépôt public peut amener un agent branché sur GitHub par MCP à divulguer des données de dépôts privés : un problème d’architecture de l’agent, pas une faille du serveur de GitHub.
  • Juillet 2025, des failles dans des composants très utilisés. L’outil mcp-remote (CVE-2025-6514, une exécution de commandes) et le serveur de fichiers officiel (CVE-2025-53109 et CVE-2025-53110, une sortie du dossier autorisé).
  • Septembre 2025, un faux serveur. Un paquet npm qui se faisait passer pour le serveur MCP du service d’envoi de courriels Postmark copiait en secret les messages vers une adresse extérieure ; Postmark a confirmé n’y avoir jamais été associé.
  • Avril 2026, l’interface locale. OX Security montre que l’interface locale des kits officiels (STDIO) transforme une configuration en commande exécutée, dans de nombreux produits qui s’appuient dessus.
  • Septembre et octobre 2026, des jetons mal vérifiés. Une faille de la passerelle LiteLLM, qui donnait accès à des outils MCP sans clé valide, entre au catalogue des failles activement exploitées de la CISA (CVE-2026-59822) ; le kit TypeScript officiel corrige une faille qui faisait accepter à un serveur des jetons émis pour un autre service.

L’OWASP prépare une liste dédiée à MCP, encore en version bêta, qui cite notamment la mauvaise gestion des jetons, l’empoisonnement des outils et les serveurs installés sans validation (« shadow MCP »).

Serveur local ou distant : où vivent le jeton et le journal


Serveur local

Serveur distant

Où il tourne

Sur le poste de la personne, lancé par son application d’IA

Sur un serveur partagé, appelé par le web

Où vit le jeton

Dans l’environnement du poste, souvent avec les droits de la personne

Côté serveur : l’agent présente un jeton OAuth émis pour ce serveur, qui refuse tout autre jeton

Le journal

Sur chaque poste, quand il existe

Au même endroit pour tous

Ce qu’une faille compromet

Le poste et ses secrets

Ce que le serveur a le droit de faire, borné par ses jetons

Pour une équipe

Pour les essais, isolé dans un conteneur ou un bac à sable

Publié dans un catalogue interne validé

La spécification fait d’un serveur distant protégé un serveur de ressources OAuth 2.1 : il doit vérifier que chaque jeton a été émis pour lui, et ne jamais en accepter ni en relayer un autre. Sur le terrain, on en est loin : une étude d’Astrix Security (octobre 2025) sur plus de 5 200 serveurs en code ouvert relève que 53 % reposent sur des clés d’accès statiques ou des jetons personnels, et à peine 8,5 % sur OAuth.

La checklist avant d’ajouter un serveur tiers

  1. Il vient de la source officielle de l’éditeur ; le registre officiel de MCP, encore en préversion, aide à le trouver mais ne garantit rien.
  2. Sa version est figée, comme toute dépendance, et chaque mise à jour se relit.
  3. Son code est lu, ou son éditeur connu : un paquet au nom proche de celui d’un éditeur connu est suspect tant qu’on n’a pas vérifié.
  4. Il reçoit un jeton à lui, limité à ce qu’il doit faire ; jamais le jeton personnel d’un administrateur.
  5. Ses descriptions d’outils et ses annotations sont relues à l’ajout et à chaque mise à jour : la spécification demande de les tenir pour non fiables quand le serveur ne l’est pas.
  6. Ses outils d’écriture sont repérés et passent par la confirmation d’une personne : la spécification veut qu’une personne puisse toujours refuser l’appel d’un outil.
  7. Ce qu’il peut envoyer à l’extérieur est connu, et limité.
  8. Chaque appel est journalisé : quel agent, quel outil, quels paramètres, quel résultat.
  9. Un serveur local tourne isolé, dans un conteneur ou un bac à sable.
  10. Il a un responsable, et une date de revue.

Le squelette d’un serveur interne minimal

Pour vos outils internes, un serveur maison expose exactement ce que l’agent doit pouvoir faire, et rien d’autre : un outil de lecture, un outil d’écriture qui attend la confirmation de la personne, des paramètres vérifiés par le serveur, et des jetons OAuth émis pour lui seul. L’exemple d’un outil de tickets, avec la version 2 du kit TypeScript officiel, qui suit la spécification du 28 juillet 2026 :

TypeScript
import { McpServer, acceptedContent, createMcpHandler, inputRequired, inputResponse } from '@modelcontextprotocol/server'
import type { CallToolResult, InputRequiredResult } from '@modelcontextprotocol/server'
import { createMcpExpressApp, getOAuthProtectedResourceMetadataUrl, mcpAuthMetadataRouter, requireBearerAuth } from '@modelcontextprotocol/express'
import { toNodeHandler } from '@modelcontextprotocol/node'
import * as z from 'zod/v4'
import { oauthMetadata, verifyAccessToken } from './identity.js' // votre fournisseur d’identité
import { tickets } from './tickets.js' // le client de votre outil, qui garde sa propre clé

// Le serveur vérifie lui-même les paramètres, sans se fier au modèle.
const ticketId = z.string().regex(/^T-[0-9]{1,8}$/)
const confirmation = z.object({ confirm: z.boolean() })

function buildServer() {
  const server = new McpServer({ name: 'tickets-internes', version: '1.0.0' })

  // Lecture seule : l’agent lit sans rien demander.
  server.registerTool('get_ticket', {
    title: 'Lire un ticket',
    description: "Renvoie le titre, le statut et le dernier message d’un ticket.",
    inputSchema: z.object({ id: ticketId }),
    annotations: { readOnlyHint: true, openWorldHint: false },
  }, async ({ id }): Promise<CallToolResult> => {
    const ticket = await tickets.get(id)
    return { content: [{ type: 'text', text: JSON.stringify({ title: ticket.title, status: ticket.status }) }] }
  })

  // Écriture : rien ne se passe tant que la personne n’a pas confirmé.
  server.registerTool('close_ticket', {
    title: 'Fermer un ticket',
    description: 'Ferme un ticket après la confirmation de la personne.',
    inputSchema: z.object({ id: ticketId, reason: z.string().max(500) }),
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
  }, async ({ id, reason }, ctx): Promise<CallToolResult | InputRequiredResult> => {
    const view = inputResponse(ctx.mcpReq.inputResponses, 'confirm')
    if (view.kind === 'elicit' && view.action !== 'accept') {
      return { content: [{ type: 'text', text: 'Annulé par la personne.' }], isError: true }
    }
    const answer = acceptedContent(ctx.mcpReq.inputResponses, 'confirm', confirmation)
    if (answer?.confirm !== true) {
      return inputRequired({ inputRequests: { confirm: inputRequired.elicit({ message: `Fermer ${id} ?`, requestedSchema: confirmation }) } })
    }
    await tickets.close(id, reason)
    return { content: [{ type: 'text', text: `Ticket ${id} fermé.` }] }
  })
  return server
}

// Serveur distant : il n’accepte que les jetons émis pour lui (OAuth 2.1).
const url = new URL('https://mcp.votre-entreprise.example/mcp')
const auth = requireBearerAuth({
  verifier: { verifyAccessToken },
  requiredScopes: ['tickets'],
  resourceMetadataUrl: getOAuthProtectedResourceMetadataUrl(url),
  expectedResource: url,
})
const app = createMcpExpressApp({ host: '0.0.0.0', allowedHosts: ['mcp.votre-entreprise.example'] })
app.use(mcpAuthMetadataRouter({ oauthMetadata, resourceServerUrl: url }))
const handler = createMcpHandler(buildServer)
app.all('/mcp', auth, (req, res) => void toNodeHandler(handler)(req, res, req.body))
app.listen(3000)

Les annotations (lecture seule, destructif) aident l’application à présenter l’outil, mais ne protègent de rien : la protection, ce sont la confirmation, les droits vérifiés par le serveur et le jeton limité. Le client de l’outil garde sa propre clé ; l’agent ne la voit jamais.

Les outils qu’on a branchés sur nos agents

Nos agents d’administration utilisent deux outils sensibles, branchés de deux façons :

  • La signature électronique, par un connecteur MCP bridé. Ouvert sur notre compte, sans clé dans le dépôt : l’agent lit, crée des brouillons et ajoute les signataires prévus ; nos réglages lui refusent l’envoi d’une demande de signature et la modification ou le retrait des signataires. L’envoi reste le clic d’une personne.
  • L’outil de gestion, par une interface en ligne de commande. Pas de connecteur MCP : l’agent appelle une interface dédiée, qui garde la clé dans son propre environnement et ne lui renvoie que des données filtrées.

Dans les deux cas, la même règle : la clé ne passe jamais par l’agent, et ce qui engage l’entreprise attend une personne. Les autres garde-fous, droits au plus juste, journal, arrêt, sont détaillés dans notre article sur la sécurité des agents IA.

C’est ce qu’on met en place dans Un socle commun pour tous vos agents IA, avec les garde-fous de notre offre Des agents IA sous contrôle. Voir aussi notre article sur le déploiement des agents de code, et la page IA agentique.

Questions fréquentes

MCP, c’est quoi ?

Un standard ouvert qui permet de connecter une application d’IA, comme un agent, à des systèmes extérieurs (outils, données, services) d’une façon commune à tous les éditeurs.

Un serveur MCP est-il sûr ?

Ni plus ni moins que son code, sa provenance et les droits qu’on lui donne. Un serveur officiel, en version figée, avec un jeton limité et une validation humaine des actions sensibles, présente un risque maîtrisé ; un paquet trouvé au hasard avec un jeton d’administrateur, non.

Qui maintient le protocole aujourd’hui ?

Depuis décembre 2025, l’Agentic AI Foundation, rattachée à la Linux Foundation et cofondée par Anthropic, Block et OpenAI.

Faut-il un serveur MCP par outil ?

En général, un serveur par service connecté. Moins il y a de serveurs, plus la surface d’attaque est réduite : on n’ajoute un serveur que pour un usage précis.

Sources

Écrit avec un assistant IA à partir des sources citées, faits vérifiés et relus par Mehdi Chafik le 26 octobre 2026.