Serveur MCP Neo4j connecté à ChatGPT

Ce guide reconstitue le parcours allant des matières premières à un système fonctionnel pour : Comment créer et connecter un serveur MCP Neo4j à ChatGPT. L’accent est mis sur des étapes opérationnelles, des vérifications explicites, ainsi que du code que vous pouvez intégrer directement dans un dépôt sans devoir deviner l’intention derrière lui. Pour une vue d’ensemble, définissez les entrées, le responsable de l’étape et les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché. Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un processus embrouillé.

Introduction

Pour l’introduction, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définissez des vérifications de succès et refusez toute exécution partielle silencieuse. Utilisez des contraintes et des index avant l’ingestion en masse. L’unicité des clés métier permet de transformer les fusionnements ultérieurs en opérations d’insertion ou de mise à jour prévisibles, plutôt que de créer des doublons en masse.

Le répertoire Neo4j Labs contre le serveur MCP officiel de Neo4j

Pour le dépôt Neo4j Labs par rapport au serveur MCP officiel de Neo4j, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce du coût évite des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Utilisez des contraintes et des index avant l’ingestion en masse. L’unicité des clés métier permet de transformer les fusionnements ultérieurs en opérations upsert prévisibles, plutôt que de créer des doublons en masse.

Architecture

Pour l’architecture, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Utilisez des contraintes et des index avant l’ingestion en masse. L’unicité des clés métier permet de transformer les fusionnements ultérieurs en opérations d’insertion/mise à jour prévisibles, plutôt que de créer des doublons en masse. Pour l’architecture, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’erreur doit indiquer une seule responsabilité plutôt qu’un processus embrouillé.

Prérequis

Pour les prérequis, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminations partielles silencieuses. Inspectez un échantillon du voisinage après le premier lot. Les sondes Cypher permettent de détecter les écarts dans les étiquettes et les propriétés manquantes à moindre coût que des tests de conversation bout en bout.

Étape 1 : Vérifier l’architecture Ubuntu

Pour l’Étape 1 : Vérifiez l’architecture d’Ubuntu, définissez les entrées, le responsable de l’étape ainsi que les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des jetons ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Vérifiez un échantillon du voisinage après le premier lot ; les sondes Cypher permettent de détecter plus facilement les écarts dans les étiquettes et les propriétés manquantes que des tests de chat bout en bout.

Étape 2 : Installer le serveur MCP officiel de Neo4j

Pour l’Étape 2 : Installez le serveur MCP officiel de Neo4j, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les stockages de secrets et les flags fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du graphe. Vérifiez un échantillon de voisinage après le premier lot. Les sondes Cypher permettent de détecter plus facilement les écarts de labels et les propriétés manquantes que les tests de chat bout en bout. Pour l’Étape 2 : Installez le serveur MCP officiel de Neo4j, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts volumineux. Lorsqu’une étape échoue, l’échec doit permettre d’identifier une seule action à corriger.

la responsabilité plutôt qu’un processus embrouillé.

tar -xzf neo4j-mcp_Linux_x86_64.tar.gz
chmod +x neo4j-mcp
sudo mv neo4j-mcp /usr/local/bin/neo4j-mcp

neo4j-mcp --help

python3 -m venv neo4j-mcp-venv
source neo4j-mcp-venv/bin/activate
pip install neo4j-mcp-server

Étape 3 : Comprendre les outils MCP disponibles

Pour l’Étape 3 : Comprendre les outils MCP disponibles, définissez les entrées, le responsable de l’étape et les critères d’achèvement avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les achèvements partiels silencieux. Modélisez les nœuds et les relations pour les questions que vous poserez, et non pour chaque nom dans le document. Des arêtes sparses et typées valent mieux que des graphes complexes et mystérieux.

Étape 4 : Créer un utilisateur Neo4j restreint

Pour l’étape 4 : Créer un utilisateur Neo4j restreint, définissez les paramètres d’entrée, le responsable de l’étape ainsi que les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce du coût permet d’éviter des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Modélisez les nœuds et les relations en fonction des questions que vous poserez, et non pour chaque nom dans le document. Des arêtes sparses et typées valent mieux que des graphes complexes et mystérieux.

cypher-shell \
  -a bolt://127.0.0.1:7687 \
  -u mcp_reader \
  -p 'YOUR_PASSWORD' \
  'MATCH (n) RETURN count(n) AS node_count;'

Étape 5 : Configurer Neo4j MCP en mode STDIO

Pour l’Étape 5 : Configurer Neo4j MCP en mode STDIO, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les stockages de secrets et les flags fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du graphe. Modélisez les nœuds et les relations pour les questions que vous poserez, et non pour chaque nom dans le document. Des arêtes sparses et typées valent mieux que des graphes complexes et mystérieux. Pour l’Étape 5 : Configurer Neo4j MCP en mode STDIO, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables à des scripts étendus. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsable.

plutôt qu’un pipeline enchevêtré.

export NEO4J_URI="bolt://127.0.0.1:7687"
export NEO4J_USERNAME="mcp_reader"
export NEO4J_PASSWORD="YOUR_NEO4J_PASSWORD"
export NEO4J_DATABASE="neo4j"
export NEO4J_READ_ONLY="true"
export NEO4J_TRANSPORT_MODE="stdio"
export NEO4J_LOG_LEVEL="info"
export NEO4J_LOG_FORMAT="text"

neo4j-mcp

Étape 6 : Comprendre l’alternative HTTP

Pour l’Étape 6 : Comprendre l’alternative HTTP, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des vérifications de succès et refusez les terminations partielles silencieuses. Utilisez des contraintes et des index avant l’ingestion en masse. L’unicité des clés métier permet de transformer les fusionnements ultérieurs en mises à jour prévisibles plutôt que en tempêtes de doublons.

export NEO4J_URI="bolt://127.0.0.1:7687"
export NEO4J_DATABASE="neo4j"
export NEO4J_READ_ONLY="true"
export NEO4J_TRANSPORT_MODE="http"
export NEO4J_MCP_HTTP_HOST="127.0.0.1"
export NEO4J_MCP_HTTP_PORT="8000"

unset NEO4J_USERNAME
unset NEO4J_PASSWORD

neo4j-mcp

Authorization: Basic BASE64_ENCODED_USERNAME_AND_PASSWORD

echo -n "mcp_reader:YOUR_PASSWORD" | base64

Authorization: Bearer YOUR_OAUTH_ACCESS_TOKEN

Étape 7 : Installer OpenAI tunnel-client sur Ubuntu

Pour l’étape 7 : Installez OpenAI tunnel-client sur Ubuntu, définissez les entrées, le responsable de l’étape ainsi que les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés. Utilisez des contraintes et des index avant l’ingestion en masse. L’unicité basée sur des clés métier permet de transformer les fusionnements ultérieurs en mises à jour prévisibles plutôt que en situations de doublons massifs.

tunnel-client-<version>-linux-amd64.zip

tunnel-client-<version>-linux-arm64.zip

unzip tunnel-client-<version>-linux-amd64.zip
chmod +x tunnel-client
sudo mv tunnel-client /usr/local/bin/tunnel-client

tunnel-client --version
tunnel-client help quickstart

Étape 8 : Créer le tunnel MCP sécurisé

Pour l’Étape 8 : Créer le tunnel MCP sécurisé, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les stocks de secrets et les flags fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Utilisez des contraintes et des index avant l’ingestion en masse. L’unicité des clés métier permet de transformer les fusionnements ultérieurs en opérations d’insertion/mise à jour prévisibles, plutôt que de provoquer des doublons massifs. Pour l’Étape 8 : Créer le tunnel MCP sécurisé, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité.

plutôt qu’un pipeline enchevêtré.

Name: Neo4jMCP
Description: Private tunnel for the Neo4j MCP server

tunnel_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Étape 9 : Créer la clé API en temps de exécution

Pour l’Étape 9 : Créer la clé API en temps de exécution, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminations partielles silencieuses. Inspectez un échantillon du voisinage après le premier lot. Les sondes Cypher détectent plus facilement les écarts de labels et les propriétés manquantes que les tests de chat bout en bout.

export CONTROL_PLANE_API_KEY="sk-YOUR_RUNTIME_KEY"

Étape 10 : Configurer tunnel-client pour lancer Neo4j MCP

Pour l’Étape 10 : Configurer tunnel-client pour lancer Neo4j MCP, il faut définir les entrées, le responsable de l’étape ainsi que les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrer les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels permet d’éviter des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Vérifier un échantillon du voisinage après le premier lot : les sondes Cypher permettent de détecter plus facilement les écarts dans les étiquettes ou l’absence de propriétés que des tests par chat de bout en bout.

export CONTROL_PLANE_API_KEY="sk-YOUR_RUNTIME_KEY"
export NEO4J_URI="bolt://127.0.0.1:7687"
export NEO4J_USERNAME="mcp_reader"
export NEO4J_PASSWORD="YOUR_NEO4J_PASSWORD"
export NEO4J_DATABASE="neo4j"
export NEO4J_READ_ONLY="true"
export NEO4J_TRANSPORT_MODE="stdio"

tunnel-client init \
  --sample sample_mcp_stdio_local \
  --profile neo4j-local \
  --tunnel-id "tunnel_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" \
  --mcp-command "/usr/local/bin/neo4j-mcp"

tunnel-client doctor \
  --profile neo4j-local \
  --explain

tunnel-client run --profile neo4j-local

Étape 11 : Vérifier la connectivité réseau d’Ubuntu

Pour l’Étape 11 : Vérifier la connectivité réseau d’Ubuntu, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les flags fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Vérifiez un échantillon du voisinage après le premier lot. Les sondes Cypher permettent de détecter les écarts dans les étiquettes et les propriétés manquantes à moindre coût que des tests de conversation bout en bout. Pour l’Étape 11 : Vérifier la connectivité réseau d’Ubuntu, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit permettre d’identifier une seule cause à corriger.

la faisabilité plutôt qu’un pipeline embrouillé.

curl -I https://api.openai.com

Étape 12 : Créer l’application en mode développeur de ChatGPT

Pour l’Étape 12 : Créer l’application en mode développeur de ChatGPT, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette phase comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les complétions partielles silencieuses. Modélisez les nœuds et les relations pour les questions que vous poserez, et non pour chaque nom dans le document. Des arêtes sparses et typées valent mieux que des graphes complexes et mystérieux.

Étape 13 : Valider l’intégration

Pour l’Étape 13 : Valider l’intégration, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés.

Liste de contrôle opérationnelle

Pour la liste de contrôle opérationnelle, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.

Dokumentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure.

Inspectez un échantillon du domaine après le premier lot. Les sondes Cypher permettent de détecter plus rapidement les écarts dans les étiquettes et l’absence de propriétés que les tests de chat bout en bout.

Fournissez des outils dotés de schémas restreints et d’étiquettes explicites indiquant les effets secondaires. Les hôtes doivent savoir quels appels modifient l’état avant d’approuver automatiquement.

Ajoutez un test de base qui exécute le parcours critique dans l’environnement CI en utilisant des fixtures, et non des API payantes en ligne, chaque fois que le budget le permet.

Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le parcours passe de l’environnement de démonstration aux environnements partagés.

Au préalable de promouvoir ce stack, figez les versions, créez une transcription d’ référence pour le chemin critique, et vérifiez les étapes de rollback. Les environnements partagés nécessitent des limites de débit, des contrôles d’attribution, ainsi qu’un responsable clair pour la rotation des secrets. Préférez une fiabilité solide à des démonstrations brillantes mais ponctuelles.