Aller au contenu principal

Connecter Claude à des outils et agents locaux avec MCP

Intermédiaire

Vous voulez que Claude soit le cerveau et que votre machine fournisse les mains — lire vos fichiers, interroger votre base de données, exécuter votre script, voire appeler un modèle local ou un agent local, le tout sans que vos données ne quittent l'ordinateur portable. Cette synergie a déjà un standard : le Model Context Protocol (MCP). En une phrase : MCP est un standard ouvert qui permet à un client d'IA d'appeler des outils et des données externes via de petits programmes appelés serveurs MCP — et ces serveurs peuvent s'exécuter en privé, localement, sur votre propre machine. Cette page montre ce qu'est MCP, comment l'architecture locale s'articule, comment ajouter un serveur local à Claude, et comment en construire un petit vous-même.

What you'll learn
  • Expliquer MCP en une phrase — un standard ouvert pour qu'un client d'IA puisse appeler des outils et des données externes via des serveurs MCP
  • Voir l'architecture locale : un client MCP (Claude Code / Claude Desktop) qui parle à un serveur MCP local via stdio
  • Comprendre pourquoi C'EST la synergie Claude-cerveau + capacités-locales que vous voulez
  • Ajouter un serveur MCP local à Claude avec une seule commande
  • Construire un petit serveur MCP qui expose un outil
  • Connaître la limite de confiance — les serveurs MCP agissent avec VOS privilèges, alors n'installez que ce en quoi vous avez confiance

Ce qu'est MCP (en une phrase)​

MCP est un standard ouvert pour connecter des applications d'IA à des systèmes externes. Un client d'IA (comme Claude) parle un seul protocole ; n'importe quel serveur MCP qui le parle peut se brancher et offrir au client de nouvelles capacités. L'analogie officielle est celle d'un port USB-C pour l'IA : au lieu d'une intégration sur mesure par outil, vous construisez selon un seul connecteur et cela fonctionne partout.

Anthropic a introduit MCP et l'a rendu open source, et dès le premier jour il est livré avec la prise en charge des serveurs MCP locaux pour que Claude puisse se connecter à des systèmes internes et à des jeux de données qui s'exécutent sur votre propre machine.

Un serveur MCP peut exposer trois types de choses au client :

  • Outils (tools) — des actions que le modèle peut appeler (lire un fichier, exécuter une requête, appeler une API). C'est la même forme que l'utilisation des outils native du modèle : une capacité nommée avec des entrées typées.
  • Ressources (resources) — des données que le client peut lire (fichiers, enregistrements, documents).
  • Prompts — des modèles de prompt réutilisables et paramétrés que le serveur propose.

Pour cette page, l'essentiel ce sont les outils : un serveur MCP local est la façon dont vous confiez à Claude une nouvelle capacité privée.

Pourquoi c'est la synergie que vous voulez​

Ce que les gens entendent par « Claude comme cerveau, mon ordinateur comme corps » est exactement la séparation client/serveur de MCP :

  • Claude est l'orchestrateur. Il lit votre objectif, décide quel outil appeler, l'appelle, lit le résultat et décide de l'étape suivante.
  • Les serveurs MCP locaux sont les capacités. Chacun est un petit programme que vous exécutez sur votre machine : un serveur de système de fichiers, un serveur de base de données, un wrapper autour d'un script local, voire un serveur qui appelle un modèle local ou confie du travail à un agent local.

Parce que le serveur s'exécute localement et que Claude lui parle via l'entrée/sortie standard de votre propre machine, vos données et vos actions restent sur votre matériel — le modèle orchestre, mais les lectures de fichiers, le SQL, l'exécution des scripts se font localement. C'est la version respectueuse de la vie privée du travail agentique : le cerveau dans le cloud (ou local aussi), les mains strictement sur votre poste.

Et parce que MCP est un seul standard ouvert adopté par de nombreux clients, un serveur que vous construisez n'est pas verrouillé à une seule application. Le même serveur local que vous branchez sur Claude Code peut être utilisé par d'autres clients qui parlent MCP — construisez une fois, réutilisez partout.

L'architecture locale​

Le plus petit tableau utile comporte deux parties et un canal :

  • Client MCP (hôte). L'application d'IA — par exemple Claude Code ou Claude Desktop. Elle héberge le modèle et décide quels outils appeler.
  • Serveur MCP. Un processus distinct qui annonce des outils/ressources/prompts et les exécute lorsqu'on le lui demande.
  • Transport. Pour les serveurs locaux, le client lance le serveur en tant que sous-processus et ils communiquent via stdio (entrée/sortie standard) à l'aide de messages JSON-RPC. Pas de réseau, pas de port — juste un tube local entre deux processus sur votre machine. (Des serveurs distants existent aussi, via HTTP ; cette page concerne le cas local, en stdio.)
┌─────────────────────────┐         stdio (JSON-RPC)        ┌──────────────────────────┐
│  MCP CLIENT / HOST       │ ──── launches as subprocess ──▶ │  LOCAL MCP SERVER         │
│  Claude Code / Desktop   │ ◀── tools/resources/prompts ─── │  filesystem · db · script │
│  (the model = the brain) │                                 │  · local model / agent    │
└─────────────────────────┘                                  └──────────────────────────┘
                                                              runs on YOUR machine, YOUR data

Le modèle ne touche jamais directement votre disque — il demande au serveur local, et le serveur (s'exécutant avec vos permissions) fait le travail et renvoie un résultat.

Ajouter un serveur MCP local à Claude​

Le chemin le plus rapide est la commande claude mcp add de Claude Code, qui enregistre un serveur que le client lancera via stdio. La forme générale est un nom, puis la commande qui démarre le serveur.

Guided walkthrough1 of 4
  1. Commencez par un serveur de référence officiel (p. ex. le serveur de système de fichiers) pour que le comportement soit connu. Anthropic maintient une collection de serveurs MCP de référence que vous pouvez exécuter localement — système de fichiers, git, mémoire, fetch, et plus encore.

Un claude mcp add minimal pour un serveur de système de fichiers local (tout ce qui suit -- est la commande de lancement) :

Ajouter un serveur MCP de système de fichiers local à Claude Code

claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/dir

Si vous préférez modifier la configuration directement, un serveur stdio est déclaré par la commande qui le lance. La forme ressemble à ceci :

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"]
    }
  }
}

Construire un petit serveur MCP​

Un serveur n'est qu'un programme qui utilise un SDK MCP, déclare un outil et démarre un transport stdio. Voici toute l'idée en TypeScript — un outil qui additionne deux nombres (remplacez le corps par « exécute mon script », « interroge ma BD », « appelle mon modèle local ») :

npm install @modelcontextprotocol/sdk zod
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({ name: "my-local-tools", version: "0.1.0" });

// Declare ONE tool. Inputs are typed; the body runs locally with your privileges.
server.registerTool(
  "add",
  {
    description: "Add two numbers",
    inputSchema: { a: z.number(), b: z.number() },
  },
  async ({ a, b }) => ({
    content: [{ type: "text", text: String(a + b) }],
  }),
);

// Talk to the client over stdio — this is what makes it a LOCAL server.
await server.connect(new StdioServerTransport());

Enregistrez-le auprès de Claude exactement comme n'importe quel autre serveur stdio — pointez la commande de lancement vers votre fichier :

Ajouter votre propre serveur local à Claude Code

claude mcp add my-local-tools -- node /abs/path/to/server.js

C'est la boucle complète : Claude (le cerveau) voit un nouvel outil, l'appelle quand c'est pertinent, et votre code (les mains) s'exécute localement et renvoie le résultat. Parce qu'il parle le même protocole ouvert, ce serveur fonctionne aussi dans d'autres clients MCP sans modifications.

Watch out
  • Les serveurs MCP s'exécutent avec vos privilèges et peuvent entreprendre des actions réelles — n'installez que des serveurs en qui vous avez confiance, et méfiez-vous de l'injection de prompt via les résultats des outils.

Vérifiez vos acquis​

Vérifiez vos acquis

0/4
  1. En une phrase, qu'est-ce que MCP ?
  2. Pour un serveur MCP LOCAL, comment le client lui parle-t-il habituellement ?
  3. Pourquoi construire un seul serveur MCP est-il rentable à travers les outils ?
  4. Quelle est la principale raison de vérifier un serveur avant de l'installer ?
Appuyez sur Entrée ou Espace pour retourner la carte. Utilisez les flèches gauche et droite pour naviguer entre les cartes.Terme affiché.
1 / 8
Key takeaways
  • MCP est un standard ouvert pour qu'un client d'IA puisse appeler des outils et des données externes via des serveurs MCP — Anthropic l'a introduit avec la prise en charge des serveurs locaux dès le départ.
  • L'architecture locale est simple : un client MCP (Claude Code / Desktop) lance un serveur MCP local en tant que sous-processus et lui parle via stdio — vos données restent sur votre machine.
  • C'est la synergie Claude-cerveau + capacités-locales : Claude orchestre ; les serveurs locaux (système de fichiers, BD, un script, voire un modèle ou un agent local) fournissent les mains.
  • Ajoutez un serveur avec une seule commande (claude mcp add ... -- <commande de lancement>) ; construisez-en un avec un SDK MCP en enregistrant un outil et en connectant un transport stdio.
  • MCP est largement adopté, donc un serveur local que vous construisez fonctionne avec de nombreux clients — construisez une fois, réutilisez partout.
  • Les serveurs agissent avec vos privilèges : n'installez que ce en quoi vous avez confiance et traitez les résultats des outils comme un vecteur possible d'injection de prompt.

Pour aller plus loin​

Sources et lectures complémentaires​