Neon

npx add-mcp 'https://mcp.neon.tech/mcp'

Serveur MCP Neon

Le serveur MCP Neon est un outil open source qui vous permet d'interagir avec vos bases de données Lakebase Postgres sur Neon en langage naturel.

Le Model Context Protocol (MCP) est un protocole standardisé conçu pour gérer le contexte entre les grands modèles de langage (LLM) et les systèmes externes. Ce dépôt fournit un serveur MCP distant pour Neon.

Le serveur MCP de Neon agit comme un pont entre les requêtes en langage naturel et l'API Neon. Construit sur MCP, il traduit vos requêtes en appels API nécessaires, vous permettant de gérer des tâches telles que la création de projets et de branches, l'exécution de requêtes et la réalisation de migrations de bases de données en toute simplicité.

Parmi les principales fonctionnalités du serveur MCP Neon, on trouve :

• Interaction en langage naturel : Gérez les bases de données Neon à l'aide de commandes conversationnelles intuitives.
• Gestion simplifiée des bases de données : Effectuez des actions complexes sans écrire de SQL ni utiliser directement l'API Neon.
• Accessibilité pour les non-développeurs : Permettez aux utilisateurs ayant des parcours techniques variés d'interagir avec les bases de données Neon.
• Prise en charge des migrations de bases de données : Exploitez les capacités de branchement de Neon pour les modifications de schéma de base de données initiées en langage naturel.

Par exemple, dans Claude Code ou tout client MCP, vous pouvez utiliser le langage naturel pour accomplir des tâches avec Neon, telles que :

• Let's create a new Postgres database, and call it "my-database". Let's then create a table called users with the following columns: id, name, email, and password.
• I want to run a migration on my project called "my-project" that alters the users table to add a new column called "created_at".
• Can you give me a summary of all of my Neon projects and what data is in each one?

[!WARNING]
Considérations de sécurité du serveur MCP Neon
Le serveur MCP Neon offre des capacités puissantes de gestion de bases de données via des requêtes en langage naturel. Examinez et autorisez toujours les actions demandées par le LLM avant leur exécution. Assurez-vous que seuls les utilisateurs et applications autorisés ont accès au serveur MCP Neon.

Le serveur MCP Neon est destiné au développement local et aux intégrations IDE uniquement. Nous ne recommandons pas d'utiliser le serveur MCP Neon dans des environnements de production. Il peut exécuter des opérations puissantes pouvant entraîner des modifications accidentelles ou non autorisées.

Pour plus d'informations, consultez Directives de sécurité MCP →.

Configuration du serveur MCP Neon

Il existe plusieurs options pour configurer le serveur MCP Neon :

1. Configuration rapide avec clé API (Cursor, VS Code et Claude Code) : Exécutez neon@latest init pour configurer automatiquement le serveur MCP de Neon, les compétences d'agent et l'extension VS Code avec une seule commande.
2. Serveur MCP distant (authentification basée sur OAuth) : Connectez-vous au serveur MCP géré de Neon en utilisant OAuth pour l'authentification. Cette méthode est plus pratique car elle élimine le besoin de gérer les clés API. De plus, vous recevrez automatiquement les dernières fonctionnalités et améliorations dès leur publication.
3. Serveur MCP distant (authentification basée sur clé API) : Connectez-vous au serveur MCP géré de Neon en utilisant une clé API pour l'authentification. Cette méthode est utile si vous souhaitez connecter un agent distant à Neon lorsque OAuth n'est pas disponible. De plus, vous recevrez automatiquement les dernières fonctionnalités et améliorations dès leur publication.

Prérequis

• Une application cliente MCP.
• Un compte Neon.
• Node.js (>= v18.0.0) : Téléchargez depuis nodejs.org.
• Si IP Allow est activé, ajoutez 34.192.103.46 et 23.22.233.166 à votre liste d'autorisation (mcp.neon.tech adresses IP statiques).

Pour le développement, vous aurez besoin de Node.js 22+ (pnpm est fourni via Corepack — exécutez corepack enable pour l'activer).

Option 1. Configuration rapide avec clé API

Vous ne voulez pas créer manuellement une clé API ?

Exécutez neon@latest init pour configurer automatiquement le serveur MCP de Neon avec une seule commande :

npx neon@latest init

Cela fonctionne avec Cursor, VS Code (GitHub Copilot) et Claude Code. Cela s'authentifiera via OAuth, créera une clé API Neon pour vous et configurera votre éditeur automatiquement.

Option 2. Serveur MCP distant hébergé (authentification basée sur OAuth)

Connectez-vous au serveur MCP géré de Neon en utilisant OAuth pour l'authentification. C'est la configuration la plus simple, ne nécessite aucune installation locale de ce serveur et ne nécessite pas de clé API Neon configurée dans le client.

Exécutez la commande suivante pour ajouter le serveur MCP Neon pour tous les agents et éditeurs détectés dans votre espace de travail :

npx add-mcp "https://mcp.neon.tech/mcp?category=projects&category=branches&category=endpoints&category=querying&category=schema"

Cette URL publie les projets, les branches, les points de terminaison de calcul, les requêtes et les schémas. Aperçu avec /api/list-tools?category=projects&category=branches&category=endpoints&category=querying&category=schema. L'URL non filtrée publie chaque catégorie :

npx add-mcp https://mcp.neon.tech/mcp

Ajoutez le drapeau -g pour ajouter le serveur MCP Neon à la liste globale des serveurs MCP au lieu d'une portée de projet.

Alternativement, vous pouvez ajouter l'entrée « Neon » suivante au fichier de configuration du serveur MCP de votre client (par exemple, mcp.json, mcp_config.json) :

{
  "mcpServers": {
    "Neon": {
      "type": "http",
      "url": "https://mcp.neon.tech/mcp?category=projects&category=branches&category=endpoints&category=querying&category=schema"
    }
  }
}

Kiro : Ajoutez ce qui suit à votre fichier de configuration MCP Kiro (~/.kiro/settings/mcp.json pour global, ou .kiro/settings/mcp.json pour une portée de projet) :

{
  "mcpServers": {
    "Neon": {
      "url": "https://mcp.neon.tech/mcp?category=projects&category=branches&category=endpoints&category=querying&category=schema"
    }
  }
}

Ou utilisez le bouton d'installation en un clic en haut de ce README. Pour plus d'informations, consultez la documentation MCP Kiro.

• Redémarrez ou actualisez votre client MCP.
• Une fenêtre OAuth s'ouvrira dans votre navigateur. Suivez les invites pour autoriser votre client MCP à accéder à votre compte Neon.

Avec l'authentification basée sur OAuth, le serveur MCP fonctionnera, par défaut, sur les projets de votre compte Neon personnel. Pour accéder aux projets appartenant à une organisation ou les gérer, vous devez explicitement fournir soit org_id ou project_id dans votre invite au client MCP.

Option 3. Serveur MCP distant hébergé (authentification basée sur clé API)

Le serveur MCP distant prend également en charge l'authentification à l'aide d'une clé API dans l'en-tête Authorization si votre client le prend en charge.

Créez une clé API Neon dans la console Neon. Ensuite, exécutez la commande suivante pour ajouter le serveur MCP Neon pour tous les agents et éditeurs détectés dans votre espace de travail :

npx add-mcp "https://mcp.neon.tech/mcp?category=projects&category=branches&category=endpoints&category=querying&category=schema" --header "Authorization: Bearer <$NEON_API_KEY>"

Alternativement, vous pouvez ajouter l'entrée « Neon » suivante au fichier de configuration du serveur MCP de votre client (par exemple, mcp.json, mcp_config.json) :

{
  "mcpServers": {
    "Neon": {
      "type": "http",
      "url": "https://mcp.neon.tech/mcp?category=projects&category=branches&category=endpoints&category=querying&category=schema",
      "headers": {
        "Authorization": "Bearer <$NEON_API_KEY>"
      }
    }
  }
}

Fournissez une clé API d'une organisation pour limiter l'accès aux projets de l'organisation uniquement.

Portées et mode lecture seule

Neon MCP annonce les portées OAuth read et write. Votre client MCP peut les demander, ou vous pouvez faire la sélection dans l'interface utilisateur des autorisations OAuth. * est traité comme écriture si un client l'envoie toujours.

Le mode lecture seule restreint les outils disponibles, désactivant les opérations d'écriture comme la création de projets, de branches ou l'exécution de migrations. Les outils en lecture seule incluent la liste des projets, la description des schémas, l'interrogation des données et l'affichage des métriques de performance.

Vous pouvez définir le mode lecture seule de deux manières :

1. URL MCP par défaut (consentement modifiable) : Connectez-vous avec https://mcp.neon.tech/mcp et décochez Autoriser les écritures sur la page d'autorisation. Vous pouvez également choisir un projet et un sous-ensemble de catégories d'outils là-bas.
2. URL MCP paramétrée (consentement fixe) : Mettez readonly, projectId et/ou category sur l'URL du serveur MCP. La page d'autorisation confirme cette autorisation et ne propose pas d'éditeurs. Modifiez l'URL et autorisez à nouveau pour modifier l'autorisation.

{
  "mcpServers": {
    "Neon": {
      "url": "https://mcp.neon.tech/mcp?readonly=true"
    }
  }
}

Comment le paramètre de requête se comporte :

• Flux de clé API : readonly=true est le moyen d'activer le mode lecture seule (il n'y a pas d'échange de portée OAuth dans ce flux). Les modifications d'URL s'appliquent à la prochaine requête.
• Flux OAuth : projectId, category et readonly sur l'URL MCP sont une autorisation fixe confirmée lors de l'autorisation. readonly=true ne peut pas être élargi aux écritures sur cette page. Après l'émission d'un jeton, la modification de l'URL n'élargit pas ce jeton ; autorisez à nouveau.

Pour l'enregistrement OAuth, x-read-only est un paramètre initial « Autoriser les écritures » par défaut sur le consentement modifiable. Il ne verrouille pas la confirmation et ne réduit pas une URL paramétrée qui inclut readonly=false. Les requêtes par clé API honorent toujours x-read-only par requête, en dessous du paramètre de requête readonly.

Remarque : Le mode lecture seule restreint les outils disponibles. De plus, l'outil run_sql reste disponible uniquement pour les requêtes en lecture seule.

Paramètres de requête URL pour le contrôle d'accès

Le contexte d'autorisation (catégories de portée, portée du projet, mode lecture seule) est configuré via des paramètres de requête URL sur l'URL du serveur MCP. Les requêtes par clé API appliquent ces paramètres à chaque requête. Les jetons OAuth stockent l'autorisation confirmée ou modifiée lors de l'autorisation.

Paramètre	Description	Exemple
readonly	Activer le mode lecture seule (true/false)	?readonly=true
category	Restreindre à des catégories d'outils spécifiques (répété ou CSV)	?category=querying&category=schema
projectId	Limiter toutes les opérations à un seul projet	?projectId=proj-123

Exemple de lecture seule + portée de projet :

{
  "mcpServers": {
    "Neon": {
      "url": "https://mcp.neon.tech/mcp?readonly=true&projectId=my-project-id"
    }
  }
}

Exemple de filtre par catégorie (uniquement les outils de requête et de schéma) :

{
  "mcpServers": {
    "Neon": {
      "url": "https://mcp.neon.tech/mcp?category=querying&category=schema"
    }
  }
}

Vous pouvez prévisualiser les outils visibles pour toute configuration à l'aide du point de terminaison /api/list-tools (aucune authentification requise) :

curl "https://mcp.neon.tech/api/list-tools?readonly=true&category=querying"

Outils disponibles en mode lecture seule

Outils hôtes : list_organizations, describe_branch, run_sql, run_sql_transaction, get_database_tables, describe_table_schema, list_slow_queries, explain_sql_statement, inspect_database, get_neon_auth_config, search, fetch, list_docs_resources, get_doc_resource.

Outils d'API de gestion générés qui sont GET et ne renvoient pas de secrets, plus query_logs (POST, lecture seule). Prévisualisez l'ensemble exact avec /api/list-tools?readonly=true.

Outils nécessitant un accès en écriture :

• Écritures d'API de gestion générées (create_project, create_branch, delete_project, …)
• get_connection_string (la chaîne de connexion contient un mot de passe de rôle privilégié, il est donc retenu en mode lecture seule ; copiez-le depuis la console Neon à la place)
• prepare_database_migration, complete_database_migration
• prepare_query_tuning, complete_query_tuning

Transport Server-Sent Events (SSE) (obsolète)

MCP prend en charge deux transports de serveur distant : le Server-Sent Events (SSE) obsolète et le Streamable HTTP plus récent et recommandé. Si votre client LLM ne prend pas encore en charge Streamable HTTP, vous pouvez passer le point de terminaison de https://mcp.neon.tech/mcp à https://mcp.neon.tech/sse pour utiliser SSE à la place.

Exécutez la commande suivante pour ajouter le serveur MCP Neon pour tous les agents et éditeurs détectés dans votre espace de travail en utilisant le transport SSE :

npx add-mcp https://mcp.neon.tech/sse --type sse

Architecture du serveur distant

Le serveur distant s'exécute comme une application Next.js App Router sur Vercel à mcp.neon.tech.

[!NOTE] Le chemin racine / redirige vers la documentation du serveur MCP Neon. Il n'y a pas de page d'accueil.

Domaines d'implémentation principaux :

• app/api/[transport]/route.ts : point de terminaison de transport MCP pour Streamable HTTP (/mcp) et SSE (/sse)
• app/api/authorize/, app/callback/, app/api/token/, app/api/revoke/ : points de terminaison du flux OAuth
• app/.well-known/ : points de terminaison de métadonnées de découverte OAuth
• mcp/ : serveur MCP, outils, gestionnaires, analyses et intégration Sentry
• lib/ : assistants compatibles Next.js (OAuth, configuration, gestion des erreurs)
• mcp/utils/read-only.ts : gestion du mode lecture seule et des portées

Guides

• Guide du serveur MCP Neon
• Connecter les clients MCP à Neon
• Cursor avec le serveur MCP Neon
• Claude Code avec le serveur MCP Neon
• Claude Desktop avec le serveur MCP Neon
• Cline avec le serveur MCP Neon
• Windsurf avec le serveur MCP Neon
• Zed avec le serveur MCP Neon

Fonctionnalités

Outils pris en charge

Le serveur MCP Neon fournit les actions suivantes, exposées comme « outils » aux clients MCP. Vous pouvez utiliser ces outils pour interagir avec vos projets et bases de données Neon à l'aide de commandes en langage naturel.

Métadonnées de portée des outils

Chaque définition d'outil inclut une catégorie scope utilisée pour le filtrage des outils basé sur les autorisations et l'UX de consentement. Les catégories actuelles sont :

• projects
• branches
• endpoints
• snapshots
• schema
• querying
• neon_auth
• data_api
• observability
• docs
• functions
• storage
• null (outils sans catégorie de portée)

Remarques :

• Les outils de l'API de gestion proviennent de @neon/tools. Les sélecteurs sont des chemins SDK (projects.list) ; les noms MCP publiés sont orientés verbe (list_projects, delete_project, query_logs). Les noms historiques restent là où ils existaient déjà (describe_project, create_branch, reset_from_parent, compare_database_schema, provision_neon_auth, provision_neon_data_api, list_branch_computes).
• ?category=branches inclut les outils de branche, de rôle et de base de données (list_postgres_roles, create_postgres_database, …). Un jeton déjà émis pour branches obtient ces écritures. La liste des calculs est ?category=endpoints. La restauration de snapshot est ?category=snapshots.
• Les écritures de membres de projet et de permissions ne sont pas publiées. list_project_members et list_project_permissions sont des lectures.
• Les outils de schéma (?category=schema) sont les outils hôtes get_database_tables et describe_table_schema, plus les compare_database_schema générés.
• L'application de la lecture seule repose toujours sur readOnlySafe et la logique de lecture seule côté serveur ; scope est une métadonnée de catégorie, pas un interrupteur de lecture/écriture autonome.
• En mode limité au projet (?projectId=...), les outils sans chemin de projet (list_projects, create_project, list_organizations, list_regions, search, fetch, …) sont masqués. delete_project est également masqué.

Gestion de projet :

• list_projects : Liste les projets Neon. limit limite le nombre d'éléments renvoyés.
• describe_project : Récupère un projet Neon par identifiant ({ "project_id": "…" }).
• create_project : Crée un projet Neon et attend le calcul par défaut. Ne renvoie pas de chaîne de connexion. Les arguments sont { "name": "…", "org_id": "…", "region_id": "…" }. Appelez get_connection_string après son succès.
• delete_project : Supprime un projet Neon existant. Les arguments sont { "project_id": "…" }.
• list_organizations : Liste toutes les organisations auxquelles l'utilisateur actuel a accès. Filtre optionnellement par nom ou identifiant d'organisation à l'aide du paramètre de recherche.

Gestion des branches :

• list_branches : Liste les branches d'un projet. Utilisez-le pour résoudre un nom de branche en identifiant br-….
• list_credentials, create_credential, revoke_credential, rotate_credential : Identifiants limités à la branche pour le stockage d'objets et la passerelle IA. reveal n'est pas un outil ; la rotation remplace les secrets en place et n'est pas idempotente.
• create_branch : Crée une branche avec un calcul en lecture-écriture et attend qu'elle soit prête. Ne renvoie pas de chaîne de connexion. Les arguments sont { "project_id": "…", "name": "feature-x" }. Passez no_compute: true pour ignorer le point de terminaison. Appelez get_connection_string après son succès.
• reset_from_parent : Réinitialise une branche à la HEAD actuelle de sa branche parente ({ "project_id": "…", "branch_id": "br-…" }). Ignore les écritures depuis la divergence de la branche. preserve_under_name est requis lorsque la branche a des enfants ; ces enfants passent à la nouvelle branche. HEAD parent uniquement ; la restauration à un instant précis est restore_snapshot.
• delete_branch : Supprime une branche ({ "project_id": "…", "branch_id": "br-…" }).
• describe_branch : Récupère une arborescence de bases de données, schémas, tables, vues et fonctions sur une branche.
• Les outils de branche générés prennent branch_id comme identifiant de branche (br-...), pas un nom.
• restore_snapshot : Restaure un snapshot. Passez target_branch_id pour restaurer sur une branche existante ; omettez-le pour en créer une nouvelle.

Points de terminaison de calcul (?category=endpoints) :

• list_postgres_endpoints, list_branch_computes, get_postgres_endpoint, create_postgres_endpoint, update_postgres_endpoint, delete_postgres_endpoint, start_postgres_endpoint, suspend_postgres_endpoint, restart_postgres_endpoint

Snapshots (?category=snapshots) :

• list_snapshots, get_snapshot_schedule, set_snapshot_schedule, create_snapshot, update_snapshot, delete_snapshot, restore_snapshot

Schéma (?category=schema) :

• get_database_tables, describe_table_schema
• compare_database_schema : Diff de schéma SQL d'une base de données par rapport à une autre branche. database_name est requis. Omettre base_branch_id compare à la branche parente. Les options lsn, timestamp, base_lsn, base_timestamp sont uniquement pour un instant précis.

Exécution de requêtes SQL :

• get_connection_string : Renvoie votre chaîne de connexion à la base de données.
• run_sql : Exécute une seule requête SQL sur une base de données Neon spécifiée. Prend en charge les opérations de lecture et d'écriture.
• run_sql_transaction : Exécute une série de requêtes SQL dans une seule transaction sur une base de données Neon.
• get_database_tables : Liste toutes les tables d'une base de données Neon spécifiée.
• describe_table_schema : Récupère la définition de schéma d'une table spécifique, détaillant les colonnes, les types de données et les contraintes.

Migrations de base de données (modifications de schéma) :

• prepare_database_migration : Lance un processus de migration de base de données. De manière cruciale, il crée une branche temporaire pour appliquer et tester la migration en toute sécurité avant d'affecter la branche principale.
• complete_database_migration : Finalise et applique une migration de base de données préparée à la branche principale. Cette action fusionne les modifications de la branche de migration temporaire et nettoie les ressources temporaires.

Requêtes et optimisation SQL :

• inspect_database : Exécute l'un des 15 diagnostics Postgres prédéfinis en lecture seule sur une branche — tailles des relations et des index, utilisation des index et des scans séquentiels, requêtes actives et verrous, requêtes les plus lourdes et les plus fréquentes, taux de succès du cache et taille de l'ensemble de travail, estimations d'autovacuum et de bloat, et état de réplication. Mêmes vérifications que la commande CLI neon inspect db. Omettez database_name pour couvrir chaque base de données de la branche ; passez un nom pour en inspecter une. Quatre d'entre elles nécessitent l'extension pg_stat_statements ou neon.
• list_slow_queries : Identifie les goulots d'étranglement de performance en trouvant les requêtes les plus lentes d'une base de données. Nécessite l'extension pg_stat_statements.
• explain_sql_statement : Fournit des plans d'exécution détaillés pour les requêtes SQL afin d'identifier les goulots d'étranglement de performance.
• prepare_query_tuning : Analyse les performances des requêtes et suggère des optimisations, comme la création d'index. Crée une branche temporaire pour tester ces optimisations en toute sécurité.
• complete_query_tuning : Finalise l'optimisation des requêtes en appliquant les optimisations à la branche principale ou en les rejetant. Nettoie la branche d'optimisation temporaire.

Neon Auth (?category=neon_auth) :

• provision_neon_auth, get_auth, disable_auth, update_auth_config
• get_neon_auth_config : outil hôte ; secrets masqués. Utilisez les outils d'écriture Auth générés pour modifier les paramètres.
• list_auth_oauth_providers, add_auth_oauth_provider, update_auth_oauth_provider, delete_auth_oauth_provider
• list_auth_trusted_domains, add_auth_trusted_domain, delete_auth_trusted_domain
• create_auth_user, delete_auth_user, update_auth_user_role

Neon Data API (?category=data_api) :

• provision_neon_data_api, get_data_api, update_data_api, delete_data_api : Gérez la Data API pour une base de données de branche.

Recherche et découverte :

• search : Recherche dans les organisations, projets et branches correspondant à une requête. Renvoie les identifiants, titres et liens directs vers la console Neon.
• fetch : Récupère des informations détaillées sur une organisation, un projet ou une branche spécifique à l'aide d'un identifiant (généralement issu de l'outil de recherche).

Observabilité (?category=observability) : ces outils nécessitent la plateforme Neon Beta et ne sont actuellement disponibles que pour les projets de la région aws-us-east-2. Une branche sans accès aux journaux renvoie HTTP 404 avec la raison telemetry_not_enabled.

• query_logs : Interroge les journaux OpenTelemetry pour une branche. POST dans l'API de gestion ; traité comme lecture seule par ce serveur.
• list_log_fields : Liste les champs de journaux pour lesquels vous pouvez énumérer les valeurs sur une branche.
• list_log_field_values : Liste les valeurs distinctes d'un champ de journal dans une branche et une fenêtre temporelle.

Documentation et ressources (?category=docs) :

• list_docs_resources : Liste toutes les pages de documentation Neon disponibles en récupérant l'index depuis https://neon.com/docs/llms.txt. Renvoie les URL et titres de pages qui peuvent être récupérés individuellement à l'aide de l'outil get_doc_resource.
• get_doc_resource : Récupère une page de documentation Neon spécifique sous forme de contenu markdown. Utilisez d'abord l'outil list_docs_resources pour découvrir les slugs de pages disponibles, puis passez le slug à cet outil.

Fonctions (?category=functions) :

• list_functions, get_function, update_function, delete_function, deploy_function
• list_functions_custom_domains, register_functions_custom_domain, delete_functions_custom_domain
• list_triggers, get_trigger, create_trigger, update_trigger, delete_trigger : Déclencheurs de fonction planifiés (type: "schedule", cron UTC à cinq champs).

Stockage (?category=storage) :

• list_storage_buckets, create_storage_bucket, delete_storage_bucket
• list_storage_objects, delete_storage_object, delete_storage_objects_by_prefix
• presign_storage_object, get_storage

Migrations

Les migrations sont un moyen de gérer les modifications du schéma de votre base de données au fil du temps. Avec le serveur MCP Neon, les LLM sont habilités à effectuer des migrations en toute sécurité avec des commandes distinctes « Démarrer » (prepare_database_migration) et « Valider » (complete_database_migration).

La commande « Démarrer » accepte une migration et l'exécute dans une nouvelle branche temporaire. Au retour, cette commande indique au LLM qu'il doit tester la migration sur cette branche. Le LLM peut ensuite exécuter la commande « Valider » pour appliquer la migration à la branche d'origine.

Développement

Ce projet utilise pnpm comme gestionnaire de paquets, épinglé via Corepack.

Structure du projet

Le code du serveur MCP se trouve à la racine du dépôt, une application Next.js déployée sur Vercel à mcp.neon.tech.

corepack enable
pnpm install

Voir CONTRIBUTING.md pour savoir comment ajouter des outils. Les arguments d'outil sont snake_case.

Développement local

# Start the Next.js dev server (for the remote MCP server)
pnpm dev

Linting et vérification des types

pnpm lint
pnpm typecheck

Variables d'environnement

Requis pour l'exécution du serveur distant :

Variable	Description
SERVER_HOST	URL du serveur (par défaut VERCEL_URL)
UPSTREAM_OAUTH_HOST	URL du fournisseur OAuth Neon
CLIENT_ID	Identifiant client OAuth
CLIENT_SECRET	Secret client OAuth
KV_URL	URL Vercel KV (Upstash Redis)
OAUTH_DATABASE_URL	URL Postgres pour le stockage des jetons

Optionnel :

Variable	Description
LOG_LEVEL	Niveau de journalisation Winston : error, warn, info (par défaut), debug, verbose, silly
NEON_MCP_DISABLE_ANALYTICS	Définir sur 1 pour désactiver les analytics produit

Pyramide de tests

Tous les tests s'exécutent depuis la racine du dépôt.

# Unit tests
pnpm test:unit

# Integration tests
pnpm test:integration

# MCP protocol end-to-end tests (real MCP client/server tool calls)
pnpm test:e2e:mcp

# Website end-to-end tests (Playwright; provisions/validates ephemeral DB first)
pnpm test:e2e:web

# Full end-to-end suite
pnpm test:e2e

# Full test pyramid (unit + integration + e2e; used in CI)
pnpm test

Stratégie de test :

• Privilégier les tests E2E pour le transport/protocole et le comportement visible par l'utilisateur.
• Utiliser les tests d'intégration pour les contrats d'outils déterministes et le comportement des workflows.
• Utiliser les tests unitaires pour la logique pure et les cas limites.
• Éviter de dépendre de la disponibilité de services tiers dans les tests de validation de fusion ; simuler les dépendances externes dans les niveaux d'intégration/unitaires.

Déploiement

Vercel déploie automatiquement le serveur distant à partir de la configuration de la branche du dépôt. Des environnements de prévisualisation sont disponibles pour les pull requests.

Télémétrie

Le serveur MCP Neon collecte des analytics produit et des rapports d'erreurs pour nous aider à comprendre l'utilisation et améliorer la fiabilité :

• Analytics produit (Segment) : lorsque vous vous connectez avec un compte authentifié, le serveur envoie un événement identify avec votre identifiant de compte Neon, votre nom et votre adresse e-mail. Il suit également le début de session (server_init), chaque appel d'outil (tool_call) et les erreurs serveur inattendues (server_error). Un événement d'appel d'outil inclut le nom de l'outil, la méthode d'authentification et le client, mais pas les arguments de l'outil ni les résultats de requête. Les appels d'outils de documentation uniquement, sans compte, sont suivis de manière anonyme. Les événements sont envoyés à track.neon.tech, le point de terminaison d'analytics de Neon.
• Rapports d'erreurs (Sentry) : les erreurs serveur inattendues sont signalées avec des traces de pile et le contexte de la requête.

Cette collecte est couverte par la Politique de confidentialité de Neon. Pour désactiver les analytics lorsque vous exécutez le serveur vous-même, définissez NEON_MCP_DISABLE_ANALYTICS=1. Ce drapeau ne désactive pas Sentry.