Passer au contenu principal

​
Introduction

Les serveurs MCP te permettent de connecter des sources de données personnalisées et de les rendre disponibles dans Cursor. C’est particulièrement utile quand tu as besoin de contexte depuis un navigateur, une base de données ou des journaux d’erreurs et système. Configurer un serveur MCP est simple, et avec Cursor, ça se fait rapidement. Dans ce guide, on va voir comment créer un serveur MCP pour Postgres. L’objectif est de permettre à Cursor d’exécuter des requêtes SQL directement sur une base de données Postgres et d’exposer les schémas de tables de façon structurée.
Ce tutoriel est conçu pour enseigner les bases de la création de serveurs MCP.

​
Qu’est-ce qu’un serveur MCP ?

Un serveur MCP est un processus qui communique avec Cursor et donne accès à des données ou actions externes. Il peut être implémenté de plusieurs façons, mais ici on va utiliser la méthode la plus simple : un serveur qui tourne en local sur ton ordinateur via stdio (flux standard d’entrée/sortie). Ça évite des considérations de sécurité complexes et nous permet de nous concentrer sur la logique MCP elle-même. L’un des cas d’usage les plus courants de MCP est l’accès aux bases de données. Quand tu construis des dashboards, exécutes des analyses ou crées des migrations, il est souvent nécessaire d’interroger et d’inspecter une base de données. Notre serveur MCP pour Postgres prendra en charge deux capacités principales : exécuter des requêtes arbitraires et lister les schémas de tables. Même si ces deux tâches pourraient être réalisées en SQL « pur », MCP offre des fonctionnalités qui les rendent plus puissantes et plus largement utiles. Les outils permettent d’exposer des actions comme l’exécution de requêtes, tandis que les ressources nous permettent de partager un contexte standardisé, par exemple des informations de schéma. Plus loin dans ce guide, on verra aussi les prompts, qui permettent des workflows plus avancés. Sous le capot, on va s’appuyer sur le package npm postgres pour exécuter des instructions SQL sur la base de données. Le SDK MCP servira de wrapper autour de ces appels, ce qui nous permet d’intégrer les fonctionnalités de Postgres de manière transparente dans Cursor.

​
Comment créer le serveur MCP

La première étape pour créer le serveur, c’est de configurer un nouveau projet. On commence par créer un nouveau dossier et initialiser un projet Bun 
> mkdir postgres-mcp-server
> Bun init
À partir d’ici, on va sélectionner le projet Blank. Une fois notre boilerplate en place, on doit installer les dépendances nécessaires. zod est requis pour définir des schémas d’E/S dans le SDK MCP 
bun add postgres @modelcontextprotocol/sdk zod
À partir d’ici, on va aller sur les dépôts de chacune des bibliothèques et récupérer le lien vers le contenu brut de leurs README respectifs. On s’en servira comme contexte pour construire le serveur Maintenant, on va définir le comportement attendu du serveur. Pour ça, on va créer un spec.md et décrire les objectifs de haut niveau 
# Spécifications

- Autoriser la définition de DATABASE_URL via la configuration d’environnement MCP
- Interroger les données Postgres via l’outil
  - Par défaut, en lecture seule
  - Autoriser les opérations d’écriture en définissant la variable d’environnement `DANGEROUSLY_ALLOW_WRITE_OPS=true|1`
- Accéder aux tables comme des `resources`
- Utiliser Zod pour les définitions de schémas
Comme tu peux le voir, c’est une spec assez légère. N’hésite pas à ajouter des détails supplémentaires si besoin. Avec les liens du README, on construira le prompt final. 
Lis ce qui suit et suis @spec.md pour comprendre ce qu’on veut. Toutes les dépendances nécessaires sont installées
- @https://raw.githubusercontent.com/modelcontextprotocol/typescript-sdk/refs/heads/main/README.md
- @https://raw.githubusercontent.com/porsager/postgres/refs/heads/master/README.md
Avec ces trois composants en place (la spécification, la doc du SDK MCP et la doc de la bibliothèque Postgres), on peut utiliser Cursor pour générer l’ossature de l’implémentation du serveur. Cursor va nous aider à assembler les pièces en générant le code qui connecte le SDK MCP à Postgres. Après quelques aller-retours dans les prompts, on a maintenant une première version du serveur MCP qui tourne. Pour l’essayer, on peut utiliser le MCP Inspector 
npx @modelcontextprotocol/inspector bun run index.ts

​
Tester le serveur MCP

Une fois la première implémentation terminée, on peut la tester avec MCP Inspector. L’inspecteur permet de voir ce que le serveur expose et de vérifier que les outils et les ressources se comportent comme prévu. Il faut confirmer que les requêtes peuvent être exécutées et que les informations de schéma sont renvoyées correctement. Interface de MCP Inspector Quand tout semble correct, on peut connecter le serveur à Cursor et le tester dans un environnement réel. À ce stade, Cursor pourra utiliser le serveur MCP Postgres comme s’il s’agissait d’une fonctionnalité intégrée, ce qui nous permettra d’interroger et d’inspecter la base de données directement.

​
Prochaines étapes

Exécuter le serveur MCP localement via stdio est un excellent point de départ, mais les équipes ont souvent besoin d’un accès partagé à la même base de données via leur serveur MCP. Dans ces cas, déployer le serveur MCP comme service HTTP centralisé devient nécessaire. Un serveur MCP déployé offre plusieurs avantages par rapport aux instances stdio individuelles :
  • Accès partagé à la base de données : plusieurs membres de l’équipe peuvent interroger la même instance de base de données via Cursor
  • Configuration centralisée : les mises à jour de schéma et les modifications d’autorisations sont gérées en un seul endroit
  • Sécurité renforcée : authentification adaptée, limitation de débit et contrôles d’accès peuvent être mis en place
  • Observabilité : les schémas d’utilisation et les métriques de performance peuvent être suivis à l’échelle de l’équipe
Pour y parvenir, tu passerais du transport stdio à HTTP. On ne couvrira pas toute la configuration, mais voici une bonne consigne de départ que tu peux donner à Cursor 
Sur la base du serveur MCP existant, crée un nouveau fichier qui implémente le protocole HTTP.

Déplace la logique partagée dans mcp-core, et nomme chaque implémentation de transport explicitement (mcp-server-stdio, mcp-server-http)

@https://raw.githubusercontent.com/modelcontextprotocol/typescript-sdk/refs/heads/main/README.md
Les résultats finaux sont disponibles ici : pg-mcp-server