Connecter une base de données à un assistant semble un confort évident. Au lieu d'écrire une requête, tu demandes le nombre de commandes de la semaine dernière et tu obtiens une réponse avec la requête qui l'a produite.
Le confort est réel, et le risque plus grand qu'avec tout autre outil de cette classe. Une base de données de production est un endroit où une erreur ne se manifeste pas par une moins bonne réponse mais par des données supprimées.
Ce texte s'ouvre sur une histoire qui l'illustre, car elle concerne un outil encore utilisé chaque semaine par des dizaines de milliers de personnes bien qu'il ait été retiré.
Un mode lecture seule qui n'en était pas un
Le serveur de référence officiel pour PostgreSQL, publié avec le protocole, proposait un mode qui limitait un assistant à la lecture. Il paraissait sensé et comportait une faille qui supprimait entièrement cette restriction.
Le mécanisme enveloppait une requête dans une transaction marquée en lecture seule. Le texte arrivant du modèle partait en entier dans l'appel de requête simple du pilote, qui exécute plusieurs instructions séparées par des points-virgules en un seul aller-retour, donc rien n'empêchait de fermer cette transaction et d'exécuter d'autres instructions dans la même chaîne.
Une requête qui commençait par valider la transaction en cours, suivie de n'importe quelle opération, suffisait. La protection disparaissait, et l'instruction suivante s'exécutait avec tous les privilèges de la connexion, ce qui incluait la suppression d'un schéma avec tout son contenu.
Le projet a été archivé en 2025 et les paquets marqués comme dépréciés. Il est néanmoins encore téléchargé des dizaines de milliers de fois par semaine, car des tutoriels vieux de deux ans y renvoient, et l'avis de dépréciation n'est vu que de celui qui le cherche.
La conclusion pratique est simple et vaut la peine d'être répétée : si un paquet de ce nom apparaît dans ta configuration, remplace-le. Des remplacements qui corrigent cette faille existent et restent maintenus ; le correctif côté outil consiste à envoyer la requête comme instruction préparée, car ce chemin refuse de transporter plusieurs instructions à la fois.
Ce que cette histoire enseigne
Tirer des conclusions plus larges qu'un seul paquet est rentable, car elles concernent toute une classe d'outils.
La première : une restriction écrite dans le code d'un outil n'est pas un contrôle de sécurité. Un mode lecture seule implémenté en enveloppant une requête dépend de la possibilité de prolonger la requête, et avec un texte venant d'un modèle, c'est toujours possible.
La deuxième : la vraie restriction appartient à la base de données plutôt qu'à l'outil. Un compte avec des privilèges en lecture seule n'effectuera pas d'écriture, quoi qu'il arrive dans la requête et quelle que soit l'habileté de sa formulation.
Cette deuxième conclusion a une limite qu'il faut connaître, car une couche où déplacer la restriction n'existe pas partout. Le serveur de système de fichiers garde ses répertoires autorisés par une vérification dans son propre code, et cette vérification tient, car elle compare un chemin résolu, une chose finie, plutôt qu'un texte de requête, qui peut toujours être prolongé. La différence n'est donc pas de savoir si la vérification vit dans le code de l'outil, mais si elle vérifie une valeur fermée ou un langage.
La troisième : la présence dans un catalogue d'outils ne signifie ni actualité ni sécurité. Le registre, traité dans l'article sur le catalogue de serveurs, stocke des descriptions et vérifie des noms ; il n'effectue aucune revue de code.
La quatrième, la plus inconfortable : un outil peut être officiel et en même temps impropre à l'usage. La signature d'un éditeur renseigne sur l'origine, pas sur la qualité ni sur le fait que quelqu'un le maintienne encore.
Comment faire cela en sécurité
Trois couches, chacune fonctionnant indépendamment des autres. Mets-les toutes les trois en place, car chacune échoue différemment.
La première est un compte de base de données séparé avec des privilèges en lecture seule et uniquement sur les tables que l'assistant doit voir.
CREATE ROLE assistant_read LOGIN PASSWORD 'password';
GRANT CONNECT ON DATABASE shop TO assistant_read;
GRANT USAGE ON SCHEMA public TO assistant_read;
GRANT SELECT ON orders, products TO assistant_read;C'est la seule protection qui fonctionne quoi qu'il arrive dans une requête. Si l'assistant ne doit voir que les commandes et les produits, la table des données des employés se trouve hors de sa portée au niveau de la base de données plutôt qu'au niveau des bonnes intentions.
La deuxième couche est une limite de temps d'exécution. Une requête sans limite peut bloquer une base de données pendant des minutes, et un modèle ne sait pas que joindre trois grandes tables sans condition tournera pendant une heure.
ALTER ROLE assistant_read SET statement_timeout = '10s';La troisième est une instance séparée ou une réplique en lecture. Un assistant qui interroge une réplique ne touche jamais la base qui sert les utilisateurs, donc même une requête mal construite n'affectera pas l'application.
Trois choses évidentes et négligées s'y ajoutent. Masquer les colonnes qui contiennent des données personnelles, car un assistant qui lit une table d'utilisateurs transmet leurs données au modèle. Enregistrer les requêtes exécutées, pour savoir ce qui a été demandé. Et désactiver l'accès à la base de production dans l'environnement de développement, car c'est là que finit le plus souvent une configuration copiée à la hâte.
Rappelle-toi aussi que PostgreSQL offre une restriction d'accès au niveau de la ligne, pas seulement au niveau de la table. Sur une base multi-tenant où une table contient les données de nombreux clients, c'est le seul moyen pour un assistant de ne voir que les lignes du bon client, et cela fonctionne quelle que soit la formulation de la requête.
Ce qu'un assistant peut réellement faire avec une base de données
Décrire les usages concrètement est rentable, car ils déterminent si le risque est justifié.
Le plus utile est la lecture de la structure. Demander quelles tables contiennent les données de commandes et comment elles sont reliées fait gagner une heure de lecture d'un schéma en entrant dans un projet inconnu.
Le deuxième est l'écriture de requêtes. Un modèle qui connaît la structure produit des requêtes analytiques sensées plus vite qu'il ne faut pour se rappeler la syntaxe des fonctions de fenêtre. Relis pourtant ce qu'il a produit, car une requête qui renvoie un nombre ne dit pas si elle compte ce que tu avais demandé.
Le troisième est le diagnostic. Demander un plan d'exécution, les index manquants ou les tables qui grossissent le plus vite donne des réponses qui exigent autrement de passer par plusieurs outils.
Ce qu'il ne faut pas faire : modifier des données. Laisser un assistant corriger un enregistrement est tentant, et la différence entre en corriger un et les corriger tous est une condition manquante que le modèle ne remarquera pas, car la requête s'exécute correctement.
Les migrations de schéma appartiennent aussi à une personne. Pas parce qu'un modèle ne peut pas les écrire, mais parce que relire un changement structurel avant son exécution coûte moins cher que restaurer une sauvegarde.
Un arrangement raisonnable fonctionne ainsi : le modèle écrit la requête et la migration, une personne les lit et les exécute. L'assistant a un accès en lecture, donc il voit la structure et les données nécessaires pour écrire du code sensé, tandis que l'exécution appartient à celui qui en supporte les conséquences. Cette séparation coûte une douzaine de secondes par opération et supprime toute une catégorie de problèmes.
Taille du résultat et contexte du modèle
Un problème séparé, moins dangereux que le précédent et plus courant au quotidien : une requête qui renvoie trop de données.
Le modèle reçoit le résultat sous forme de texte qui entre dans son contexte, donc une requête qui renvoie cinq mille lignes remplira tout le contexte disponible ou sera coupée en route. Dans le premier cas, tu paies des tokens et tu perds de la place pour le reste de la conversation ; dans le second, le modèle répond à partir d'un fragment sans savoir qu'il manque quelque chose.
Trois choses limitent cela. La première est une limite de lignes par défaut côté serveur, indépendante de ce que le modèle a écrit dans sa requête. La deuxième est une instruction qui dit clairement d'utiliser l'agrégation plutôt que de récupérer des lignes pour les questions quantitatives. La troisième est de renvoyer le nombre total de lignes correspondantes à côté d'un échantillon, pour que le modèle sache qu'il voit une tranche.
Surveille aussi la largeur. Une requête qui récupère toutes les colonnes d'une table qui en contient quarante dépense du contexte sur des données dont personne n'avait besoin, et avec des tables riches en texte, elle le fait très vite.
Il en va de même pour la lecture de la structure. Un schéma de deux cents tables passé en entier occupe plus de place que le reste de la conversation, donc un serveur sensé expose séparément une liste de tables et la description d'une seule table à la demande, plutôt que de tout envoyer d'un coup.
Enregistrer les exécutions et les relire
La dernière couche, facile à oublier, qui lors d'un incident détermine si quelqu'un sait ce qui s'est passé.
Enregistre les requêtes exécutées avec les horodatages, un identifiant de session et qui les a posées. La base de données peut le faire elle-même, via un réglage qui journalise les instructions d'un compte choisi, donc il n'a pas besoin d'être intégré à l'outil.
Cet enregistrement sert trois buts. Le premier est le diagnostic après coup, quand quelqu'un remarque que quelque chose tourne plus lentement. Le deuxième est la revue de ce que les gens demandent réellement, ce qui montre généralement après un mois que dix questions reviennent constamment et méritent d'être converties en opérations nommées. Le troisième est de repérer une situation où le modèle s'est mis à poser des questions hors de son périmètre, parce qu'il a lu quelque chose qui l'y a poussé.
Définis aussi une alerte sur les requêtes qui dépassent une durée fixée. C'est le signal le plus simple que quelqu'un interroge la base de production d'une manière que personne n'avait prévue, et le seul qui arrive de lui-même.
Les serveurs parmi lesquels choisir
| Option | Point fort | Point faible | À choisir quand |
|---|---|---|---|
| Un remplaçant du serveur officiel | Faille corrigée, interface compatible | Maintenu par la communauté | Remplacer une configuration existante |
| Un serveur avec analyse de performance | Diagnostics de requêtes, modes restreints | Plus de concepts à apprendre | Travail sur la performance de la base |
| Le serveur d'un fournisseur de bases | Intégré au reste du service, authentification | Ne fonctionne qu'avec ce fournisseur | Une base dans le cloud de ce fournisseur |
| Ton propre serveur | Exactement les requêtes que tu autorises | Tu l'écris et le maintiens | Périmètre étroit et exigences élevées |
La dernière ligne mérite plus d'attention qu'elle n'en reçoit d'habitude. Au lieu de laisser un assistant exécuter des requêtes arbitraires, tu peux exposer quelques opérations nommées : vérifier l'état d'une commande, résumer les ventes d'une période, lister les produits dont le stock est bas. Le modèle les appelle avec des paramètres, et tu contrôles chaque requête.
Cette approche est plus sûre et généralement suffisante, car en pratique un assistant pose une douzaine de questions plutôt que n'importe quoi. Les outils pour construire un tel serveur sont traités dans l'article sur la boîte à outils du protocole.
Les fournisseurs de bases managées, dont ceux traités dans les articles sur Neon et Supabase, proposent leurs propres serveurs intégrés à l'authentification de leur plateforme, ce qui simplifie la mise en place quand tu travailles dans leur écosystème.
Erreurs courantes
La première est d'utiliser le serveur de référence retiré. Son mode lecture seule peut être contourné, et le projet ne reçoit aucun correctif.
La deuxième est de s'appuyer sur un mode lecture seule fourni par l'outil plutôt que par la base de données. Les privilèges du compte sont la seule restriction qu'une requête ne peut pas contourner.
La troisième est de connecter un assistant avec le compte qu'utilise l'application. Ce compte détient des privilèges d'écriture parce que l'application en a besoin, donc l'assistant les reçoit avec.
La quatrième est l'absence de limite de temps d'exécution. Une seule requête sans condition peut charger la base pendant des minutes, et un modèle n'estimera pas le coût avant de l'exécuter.
La cinquième est un accès sans besoin aux tables qui contiennent des données personnelles. Le contenu des lignes lues entre dans le contexte du modèle, donc restreins le périmètre aux tables réellement nécessaires.
La sixième est d'autoriser la modification de données. La différence entre en corriger un et tous les corriger est une condition manquante que le modèle ne remarquera pas, car la requête s'exécute correctement.
La septième est de ne pas limiter le nombre de lignes renvoyées. Une requête qui renvoie cinq mille enregistrements remplit le contexte du modèle de données que personne n'a lues, et coûte de l'argent à chacun de ces appels.
FAQ
Le serveur MCP officiel de PostgreSQL est-il sûr ?
Non. Il a été archivé en 2025 et marqué comme déprécié, et son mode lecture seule peut être contourné : une requête peut fermer la transaction protectrice et effectuer n'importe quelle opération avec tous les privilèges de la connexion. Des remplaçants qui corrigent cette faille existent.
Comment m'assurer qu'un assistant ne fait que lire ?
Via un compte de base de données séparé avec des privilèges en lecture seule et uniquement sur des tables choisies. C'est la seule protection qui fonctionne quel que soit le contenu d'une requête, car la base refuse une écriture quoi qu'il arrive du modèle.
Un assistant peut-il supprimer des données ?
Il le peut s'il se connecte avec un compte qui détient de tels privilèges. Avec un compte restreint à la lecture, il ne le peut pas, et c'est exactement pourquoi connecter un assistant avec le compte de l'application est une grave erreur de configuration.
Vaut-il la peine d'accorder l'accès à la base de production ?
Pour la lecture, via un compte restreint et de préférence sur une réplique, oui. Directement sur la base qui sert les utilisateurs, mieux vaut éviter, car une seule requête mal écrite peut la charger pendant des minutes et une limite de temps d'exécution n'agit pas toujours à temps.
Écrire son propre serveur est-il préférable ?
Sous des exigences élevées, généralement oui. Quelques opérations nommées avec des paramètres, au lieu de requêtes arbitraires, donnent un contrôle total sur ce qui atteint la base et couvrent de toute façon en pratique l'essentiel de ce que demande un assistant.
La faille est analysée dans un compte rendu d'une équipe de recherche, et le code archivé se trouve dans le dépôt des serveurs retirés.