Guide

Filesystem MCP : un assistant qui lit et écrit vos fichiers

Le serveur Filesystem MCP donne à un assistant l'accès à vos fichiers. Répertoires autorisés, protection des chemins, risque d'injection et configuration sûre.

L'équipe CodeWorlds13 min de lecture ·

Pratique Vibe coding avec Claude Code dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article10

C'est le serveur le plus souvent branché de tout l'écosystème du protocole, et en même temps celui où les enjeux sont les plus élevés. Un assistant qui a accès aux fichiers lit le code, le corrige, crée de nouveaux fichiers et déplace des éléments d'un répertoire à l'autre.

Le confort est évident, et le risque plus élevé qu'avec l'accès à une base de données ou à des documents. Les fichiers sont à la fois du code source, des clés privées, des fichiers de configuration et tout ce qui traîne sur un disque.

La bonne nouvelle : le serveur officiel a été conçu en gardant ce risque en tête et embarque des protections raisonnables. La mauvaise : la menace la plus sérieuse se situe en dehors de lui et découle du fonctionnement de l'ensemble du dispositif. J'y reviens dans une section dédiée.

Les répertoires autorisés

La protection de base est une liste de répertoires dont le serveur ne sortira pas. Vous la fournissez au lancement.

JSON
{
  "mcpServers": {
    "files": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/anna/projects/shop"
      ]
    }
  }
}

Ce seul répertoire constitue tout le monde que voit l'assistant. Toute tentative de lire quoi que ce soit en dehors se solde par un refus, quelle que soit la manière dont elle est formulée.

La seconde voie consiste à transmettre une liste de répertoires depuis le client, grâce à un mécanisme prévu par le protocole. Le client indique alors sur quoi vous travaillez en ce moment et le serveur ajuste son périmètre. Notez qu'une liste fournie par le client remplace celle donnée au lancement au lieu de s'y ajouter.

Un serveur lancé sans l'une ni l'autre de ces deux listes ne démarre pas. C'est une bonne décision de conception, car un accès par défaut à tout le disque serait le pire réglage initial possible.

Une règle pratique : nommez un projet précis plutôt qu'un répertoire personnel. La différence, c'est qu'un répertoire personnel contient des clés, des fichiers de configuration avec des mots de passe et l'historique des commandes, alors qu'un répertoire de projet contient un projet.

Protection contre la sortie du périmètre

Une liste de répertoires ne suffit pas à elle seule, car un chemin peut s'écrire de multiples façons. Le serveur traite cela à plusieurs niveaux.

Les chemins sont ramenés à leur forme canonique avant la vérification, si bien que les références qui remontent dans l'arborescence ne mènent pas hors de la zone autorisée. C'est le contournement le plus simple, et aussi le mieux couvert.

Les liens symboliques sont vérifiés d'après leur destination réelle. Un lien situé dans un répertoire autorisé mais pointant vers un répertoire personnel est rejeté. Les liens qui ne mènent nulle part le sont aussi.

Cela règle une catégorie de problèmes qui, dans une implémentation faite à la main, est la source d'erreurs la plus courante, car vérifier un chemin avant de résoudre un lien paraît correct et ne l'est pas.

Comprenez cependant les limites de cette protection. Les garde-fous concernent l'endroit où l'assistant peut aller, pas ce qu'il fait à l'intérieur du répertoire autorisé. Dans le projet nommé, il peut écraser n'importe quel fichier, et c'est un comportement voulu.

Le vrai risque

Cette section est la plus importante de tout le texte, car elle concerne une menace que les protections ci-dessus ne couvrent pas.

Un modèle invoque des outils en fonction de ce qu'il a lu. Si un texte formulé comme une instruction apparaît dans son contexte, le modèle peut l'exécuter, sans distinguer une instruction d'une donnée.

Avec un seul outil, le risque est limité. Le problème commence avec plusieurs outils à la fois, et c'est une configuration typique. Un assistant qui a accès aux fichiers et à la récupération de pages web peut lire une page contenant une instruction cachée et l'exécuter sur vos fichiers.

Ce scénario n'est pas hypothétique et a été décrit par des chercheurs en sécurité. Il suffit que le modèle récupère un contenu externe dans lequel quelqu'un a placé une instruction de lire un fichier précis et de l'envoyer quelque part. La lecture se fait dans le répertoire autorisé, donc aucune protection du serveur ne se déclenche.

Il en va de même pour des contenus issus de sources plus proches : le ticket d'un utilisateur, un commentaire dans le code, un fichier de dépendance récupéré à l'extérieur. Tout ce qu'un modèle lit peut influencer ce qu'il fait ensuite.

Trois choses limitent réellement ce risque. La première est un répertoire étroit, car il borne les dégâts quoi qu'on parvienne à persuader le modèle de faire. La deuxième est d'approuver les opérations d'écriture au lieu de les autoriser sans surveillance. La troisième est de ne rien placer dans le répertoire autorisé que vous ne puissiez pas vous permettre de perdre ou de révéler : clés, fichiers de configuration avec mots de passe et dumps de base de données.

La quatrième, la plus efficace pour un travail sérieux : séparer les outils. Un assistant qui lit du contenu externe et un assistant qui a accès aux fichiers forment un dispositif plus sûr sous la forme de deux sessions distinctes que d'une seule qui les réunit.

Ce qu'il sait faire

L'ensemble d'outils est prévisible et mérite d'être connu, car il détermine ce qu'il faut exiger au moment de l'approbation.

La lecture couvre un seul fichier ou plusieurs fichiers en un seul appel, ce qui est nettement plus rapide pour relire un projet. Le listage d'un répertoire et le parcours d'une arborescence sont aussi disponibles.

L'écriture couvre la création de fichiers, leur écrasement et l'édition par remplacement de fragments, avec un aperçu des modifications avant exécution. Cette dernière forme est la plus sûre, car elle modifie un fragment nommé au lieu d'écraser l'ensemble : une erreur n'efface donc pas le reste du fichier.

Le déplacement, la création de répertoires et la recherche de fichiers par nom sont également disponibles, avec un motif comparé au chemin complet. La recherche dans le contenu ne fait pas partie des outils : trouver tous les endroits où apparaît un nom oblige donc à ouvrir les fichiers ou à recourir à un outil distinct.

Notez une chose à propos de l'édition. Le remplacement d'un fragment ne vérifie pas que ce fragment n'apparaît qu'une seule fois. La première occurrence est remplacée, sans avertissement, et l'opération n'échoue que si rien ne correspond. Donnez au fragment une longueur suffisante pour qu'il soit sans ambiguïté et utilisez l'aperçu des modifications avant d'enregistrer, car c'est la seule protection contre un changement qui atterrit au mauvais endroit.

Gros fichiers et contexte

Un problème pratique, moins dangereux que le précédent et rencontré tous les jours : les fichiers qui ne tiennent pas dans le contexte d'un modèle.

Un fichier de trois mille lignes représente des dizaines de milliers de tokens. Charger trois fichiers de ce type remplit une grande partie de l'espace disponible, alors que le modèle doit encore y faire tenir l'instruction, l'historique de la conversation et une réponse.

Les symptômes sont trompeurs. Le modèle répond à partir d'un fragment sans signaler qu'il n'a pas vu le reste, ou décrit correctement le début d'un fichier en omettant une fonction définie à la fin. Avec l'édition, c'est pire : une modification proposée à partir d'une image incomplète peut casser quelque chose que le modèle n'a jamais vu.

Trois habitudes limitent ce problème. La première est de nommer des fichiers précis au lieu de laisser l'assistant parcourir toute une arborescence. La deuxième est de lire un fragment plutôt que le tout quand une seule fonction vous intéresse. La troisième est de travailler sur des fichiers plus petits, ce qui est de toute façon une bonne pratique pour d'autres raisons.

Sur des projets plus gros, rappelez-vous aussi que repérer les bons fichiers par leur nom coûte moins cher que de les charger un par un. Comme le serveur ne regarde pas à l'intérieur, lancez la chasse aux endroits où apparaît un nom avec un outil extérieur, et ne donnez à l'assistant que les fichiers qu'elle fait remonter.

Travailler avec un dépôt

Quelques points qui transforment un dispositif risqué en dispositif maîtrisé pendant le travail sur le code.

Partez d'un état propre dans le gestionnaire de versions. Toutes vos modifications sont commitées, le répertoire de travail est intact. Chaque changement qui apparaît ensuite vient de l'assistant et est visible dans un diff.

Relisez le diff plutôt que le résumé. Un assistant décrit ce qu'il a fait, et cette description est souvent exacte et incomplète. Un diff montre tout, y compris ce qu'il n'a pas mentionné.

Commitez par petites portions. Une instruction, une relecture, un commit. Trois instructions d'affilée sans relecture produisent un changement qui s'étend sur vingt fichiers, dans lequel il est difficile de distinguer ce que vous vouliez de ce qui s'y est ajouté.

Surveillez les fichiers que l'assistant ne devrait pas toucher. Les fichiers de verrouillage des dépendances, la configuration des outils de build et les fichiers générés sont modifiés au passage, et un changement à cet endroit peut casser le build d'une façon difficile à retracer.

Connaissez aussi la limite de périmètre de ce serveur. Il voit les fichiers sur le disque, pas un dépôt : l'historique des modifications, les issues et les pull requests ne sont pas lisibles ici, car elles se trouvent derrière l'API. Le serveur GitHub les couvre, en répartissant ses outils en groupes (toolsets) et en proposant un mode lecture seule distinct. Pendant le travail sur le code, les deux sont souvent connectés en même temps, et il est alors utile de se rappeler que vous relisez le diff en local, et non via l'API.

Un dernier point : ne gardez pas dans le répertoire du projet un fichier d'environnement contenant de vraies clés. Même exclu du gestionnaire de versions, c'est pour un assistant un fichier ordinaire dans un répertoire autorisé.

Le serveur Filesystem face aux alternatives

OptionPoint fortPoint faibleÀ choisir quand
Le serveur officielProtections de chemins éprouvées, activement maintenuÉcritures sans surveillance si le client n'exige pas d'approbationTravail sur les fichiers d'un projet
Un assistant d'éditeurContexte du projet, relecture des changements avant enregistrementNe fonctionne que dans cet éditeurTravail quotidien sur le code
Serveurs communautairesPlus d'opérations, gestion des gros fichiersLe code de quelqu'un d'autre avec accès au disqueBesoins inhabituels
Un conteneur avec un répertoire montéIsolation du reste du systèmePlus de configurationTravail sur du code de provenance inconnue

La deuxième ligne est souvent ignorée et, pour le travail sur le code, c'est généralement le meilleur choix. Des outils comme Cursor ont l'accès aux fichiers intégré, affichent les changements avant l'enregistrement et travaillent dans le contexte d'un projet : ajouter un serveur distinct n'apporte donc pas grand-chose.

La dernière ligne mérite d'être envisagée quand vous travaillez sur du code que vous ne connaissez pas. Lancer un assistant dans un conteneur avec un seul répertoire monté signifie que même l'exécution d'une instruction malveillante reste confinée à ce répertoire, sans accès au reste du système.

Configuration sûre

Un résumé sous forme de liste, car c'est la partie à laquelle on revient.

Nommez un répertoire de projet précis, jamais un répertoire personnel ni la racine. Vérifiez si ce répertoire contient un fichier avec des identifiants, car c'est l'oubli le plus courant.

Activez l'approbation des écritures dans le client s'il la propose. La lecture peut se faire sans surveillance, l'écriture plutôt pas.

Ne combinez pas l'accès aux fichiers avec des outils qui récupèrent du contenu externe dans une même session. C'est le moyen le plus simple de limiter le risque le plus sérieux, et cela ne coûte rien.

Gardez le projet sous gestionnaire de versions, avec les changements commités avant de commencer. Chaque modification de l'assistant est alors visible dans un diff et réversible d'une seule commande.

Relisez les changements avant de commiter, même quand l'assistant affirme avoir fait exactement ce que vous demandiez. C'est le même principe que la relecture du code de quelqu'un d'autre, et pour la même raison.

Erreurs fréquentes

La première est de nommer un répertoire personnel comme zone autorisée. Il contient des clés, des fichiers de configuration avec des mots de passe et l'historique des commandes, c'est-à-dire exactement ce qu'un assistant ne devrait pas voir.

La deuxième est de combiner l'accès aux fichiers avec la récupération de contenu externe dans une même session. C'est la voie la plus souvent décrite pour faire exécuter l'instruction de quelqu'un d'autre sur vos fichiers.

La troisième est d'autoriser les écritures sans confirmation. La lecture est réversible, l'écrasement d'un fichier ne l'est pas forcément.

La quatrième est de travailler sans gestionnaire de versions. Sans lui, une modification faite par l'assistant ne se distingue pas des vôtres et est irréversible.

La cinquième est de croire que les protections du serveur couvrent tout. Elles concernent l'endroit où l'assistant peut aller, pas ce qu'il fait à l'intérieur du répertoire autorisé.

La sixième est de lancer un serveur communautaire avec accès au disque sans en relire le code. Les principes de l'article sur le catalogue de serveurs s'appliquent ici doublement.

La septième est de garder dans le répertoire du projet un fichier contenant de vraies clés. L'exclure du gestionnaire de versions ne change rien, car pour l'assistant c'est un fichier ordinaire dans la zone autorisée.

FAQ

Un assistant peut-il sortir du répertoire nommé ?

Pas par un chemin. Le serveur ramène les chemins à leur forme canonique, bloque les références qui remontent dans l'arborescence et vérifie où mènent les liens symboliques. En revanche, il peut tout faire à l'intérieur du répertoire autorisé, et c'est un comportement voulu.

Quel est le plus gros risque ?

Qu'un modèle exécute des instructions trouvées dans un contenu qu'il a lu. Avec un accès simultané aux fichiers et à la récupération de pages externes, quelqu'un peut placer dans ce contenu une instruction de lire un fichier et de l'envoyer ailleurs, et le serveur n'a aucune raison de la bloquer.

Comment s'en protéger ?

Un répertoire étroit, l'approbation des opérations d'écriture et le fait de garder les éléments sensibles hors de la zone autorisée. La mesure la plus efficace reste toutefois la séparation : ne combinez pas l'accès aux fichiers avec des outils qui lisent du contenu externe dans une même session.

Est-ce mieux qu'un assistant intégré à un éditeur ?

Pour le travail sur le code, généralement non. Des outils comme Cursor ont l'accès aux fichiers intégré, affichent les changements avant l'enregistrement et comprennent le contexte du projet. Un serveur Filesystem distinct est utile quand vous travaillez en dehors d'un éditeur.

Vaut-il la peine de le lancer dans un conteneur ?

Quand vous travaillez sur du code de provenance inconnue, assurément. Un conteneur avec un seul répertoire monté signifie que même l'exécution d'une instruction malveillante reste confinée à ce répertoire, sans accès au reste du système.

Le code et la documentation se trouvent dans le dépôt des serveurs du protocole, et le paquet dans le registre npm.

À lire aussi