Quand utiliser une base de données graphe telle que Neo4j
Les apprenants identifieront les problèmes de nature graphique — moteurs de recommandation, détection des fraudes, graphes de connaissances — pour lesquels le parcours natif de Neo4j surpasse les chaînes de $lookup dans MongoDB.
Quand utiliser une base de données graphe telle que Neo4j est une leçon MongoDB Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage MongoDB Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours MongoDB Academy comprend 4 leçons au total.
Qu’est-ce qu’une base de données en graphe ?
Une base de données en graphe représente les données sous forme de nœuds (entités) et d’arêtes (relations entre les entités). Chaque arête est un objet à part entière, doté d’un type et de ses propres propriétés. Contrairement aux bases de données relationnelles ou documentaires, où les relations sont déduites de clés étrangères ou de références intégrées, les bases de données en graphe stockent les relations comme des connexions explicites, avec un parcours en O(1) pour chaque saut : suivre une relation prend un temps constant, quelle que soit la taille de la base de données.
Le problème du parcours des relations
Les bases de données documentaires et relationnelles sont optimisées pour retrouver des entités — récupérer un utilisateur par son identifiant, interroger les commandes par statut. Elles peinent à parcourir les relations — « trouver tous les amis des amis d’Alice qui ont acheté le même produit qu’Alice au cours du dernier mois ». Chaque saut nécessite un $lookup ou une jointure. Trois sauts de profondeur impliquent trois jointures imbriquées. À 10 sauts sur des millions de nœuds, les performances de MongoDB se dégradent de façon exponentielle, tandis que celles de Neo4j restent stables.
// MongoDB: 3-hop traversal — three nested $lookup stages
db.users.aggregate([
{ $match: { _id: aliceId } },
{ $lookup: { from: 'follows', localField: '_id', foreignField: 'followerId', as: 'following' } },
{ $unwind: '$following' },
{ $lookup: { from: 'follows', localField: 'following.followeeId', foreignField: 'followerId', as: 'followingOfFollowing' } },
// Expensive and increasingly slow with scale
])Neo4j et le langage de requête Cypher
Neo4j est la base de données en graphe la plus répandue. Elle utilise le langage de requête Cypher, un langage déclaratif fondé sur des motifs pour parcourir les graphes. Une requête Cypher décrit le motif de graphe recherché à l’aide d’une notation en ASCII : les nœuds sont représentés par () et les relations par -[]->. Le moteur de requêtes trouve efficacement tous les sous-graphes correspondant au motif grâce à une adjacence native sans index.
// Cypher: find Alice's second-degree connections (friends of friends)
MATCH (alice:User { name: 'Alice' })
-[:FOLLOWS]->(:User)
-[:FOLLOWS]->(foaf:User)
WHERE NOT (alice)-[:FOLLOWS]->(foaf)
AND foaf <> alice
RETURN DISTINCT foaf.name, foaf.email
LIMIT 50
// This is O(connections traversed), not O(total users in DB)Cas d’utilisation classique des graphes : moteurs de recommandation
Les systèmes de recommandation reposent sur le parcours de réseaux de relations : « les utilisateurs qui ont acheté ce que vous avez acheté ont également acheté X ». Dans un graphe, chaque achat est une arête entre un nœud utilisateur et un nœud produit. Trouver des recommandations par filtrage collaboratif consiste en un parcours à deux sauts : Utilisateur → Produit → (autres utilisateurs ayant acheté ce produit) → (autres produits achetés par ces utilisateurs). Neo4j gère des millions de ces parcours par seconde. Le $graphLookup de MongoDB peut effectuer cette opération, mais ses performances se dégradent à grande échelle.
// Cypher: collaborative filtering recommendation
MATCH (me:User { _id: 'alice123' })
-[:PURCHASED]->(p:Product)
<-[:PURCHASED]-(other:User)
-[:PURCHASED]->(rec:Product)
WHERE NOT (me)-[:PURCHASED]->(rec)
RETURN rec.name, COUNT(other) AS score
ORDER BY score DESC
LIMIT 10Détection de la fraude par analyse de graphes
Les réseaux de fraude impliquent souvent des informations d’identité partagées : plusieurs comptes utilisant le même identifiant d’appareil, numéro de téléphone, adresse IP ou adresse de facturation. Les bases de données en graphe excellent dans la détection de ces réseaux en parcourant les relations : « trouver tous les comptes reliés à ce compte suspect par des attributs communs en trois sauts maximum ». L’évaluation de la fraude en temps réel au moment de la transaction — interroger en quelques millisecondes un graphe couvrant des millions d’entités liées — est une force native de Neo4j que MongoDB ne peut égaler.
// Cypher: find fraud ring (accounts sharing device/phone/address)
MATCH (suspect:Account { id: 'acc-999' })
-[:SHARES_DEVICE|SHARES_PHONE|SHARES_ADDRESS*1..3]-(related:Account)
WHERE related.status = 'active'
RETURN related.id, related.email
LIMIT 100Graphes de connaissances
Un graphe de connaissances modélise les entités et leurs relations sémantiques — comme les informations de Wikipédia structurées sous forme de graphe. Les graphes de connaissances alimentent la reconnaissance des entités par les moteurs de recherche, les réponses factuelles des assistants d’IA et les ontologies d’entreprise. Le modèle en graphe s’y adapte naturellement : Personne connaît Personne, Personne worksAt Entreprise, Entreprise isLocatedIn Ville, Ville isCapitalOf Pays. Le parcours de ces chaînes sémantiques est précisément ce pour quoi les bases de données en graphe sont conçues.
Quand le $graphLookup de MongoDB suffit
Tous les problèmes de graphe ne nécessitent pas Neo4j. Le $graphLookup de MongoDB gère assez bien les parcours d’arbres et de graphes dans les cas suivants : hiérarchies peu profondes (moins de 5 ou 6 sauts) ; graphes de taille modérée (quelques milliers à quelques millions de nœuds) ; et requêtes de parcours peu fréquentes pouvant tolérer une latence plus élevée. Si les requêtes sur le graphe constituent une fonctionnalité secondaire d’une application principalement fondée sur des données documentaires, tout conserver dans MongoDB simplifie considérablement la pile technique.
// MongoDB $graphLookup: category hierarchy traversal
db.categories.aggregate([
{ $match: { _id: 1 } },
{
$graphLookup: {
from: 'categories',
startWith: '$_id',
connectFromField: '_id',
connectToField: 'parentId',
as: 'descendants',
maxDepth: 5
}
}
])Quand choisir Neo4j plutôt que MongoDB
Choisissez Neo4j (ou une autre base de données en graphe) lorsque les parcours profonds sur plusieurs sauts constituent une fonctionnalité essentielle (réseaux sociaux, graphes de connaissances, détection de fraude) ; lorsque la relation elle-même porte des propriétés riches (par exemple, une arête FOLLOWS enregistrant la date du suivi et indiquant s’il est réciproque) ; lorsque les requêtes sur le graphe doivent renvoyer des résultats en temps réel avec une forte concurrence ; ou lorsque l’ensemble du domaine est centré sur les relations plutôt que sur les entités. Pour les réseaux sociaux, les graphes d’identités, les topologies réseau et les graphes de dépendances, choisissez Neo4j.
Persistance polyglotte : utiliser les deux
De nombreux systèmes de grande taille utilisent une persistance polyglotte — des bases de données différentes pour des besoins différents. Une plateforme sociale peut stocker les profils utilisateurs et les publications dans MongoDB (requêtes documentaires riches), les graphes d’amitié et d’intérêts dans Neo4j (parcours rapides), les données de session dans Redis (recherches en moins d’une milliseconde) et les analyses dans un système en colonnes. Chaque base de données fait ce qu’elle sait le mieux faire. La difficulté consiste à gérer la cohérence entre les systèmes, mais les gains de performances et d’évolutivité justifient souvent cette complexité.
Comparaison des modèles de données MongoDB et Neo4j
Dans MongoDB, une relation sociale est modélisée comme un document dans une collection follows, avec les champs followerId et followeeId. Dans Neo4j, il s’agit d’une arête FOLLOWS reliant directement deux nœuds User. Le modèle en graphe élimine la collection intermédiaire et permet un parcours direct fondé sur des pointeurs. Le modèle documentaire convient mieux pour récupérer les données du profil d’un utilisateur ; le modèle en graphe convient mieux pour parcourir ses connexions sociales.
// MongoDB: relationships as documents
{ _id: ObjectId(), followerId: ObjectId('alice'), followeeId: ObjectId('bob'), createdAt: new Date() }
// Neo4j Cypher equivalent:
// (alice:User)-[:FOLLOWS { createdAt: datetime() }]->(bob:User)
// Stored as direct pointer — no intermediate collection neededPropriétés des graphes et types de relations
Les arêtes d’un graphe Neo4j possèdent un type (semblable à une étiquette) et peuvent avoir des propriétés. Un graphe social peut contenir les types d’arêtes FOLLOWS, LIKES, PURCHASED et REVIEWED, chacun possédant ses propres propriétés. Les requêtes Cypher peuvent rechercher selon le type d’arête et filtrer selon les propriétés des arêtes, ce qui permet d’effectuer des requêtes riches sur les relations. Cette approche est bien plus naturelle que de stocker un champ type dans une collection relationships de MongoDB et d’effectuer une jointure dessus.
// Cypher: find products purchased within the last 7 days by connections
MATCH (me:User { id: 'alice' })
-[:FOLLOWS*1..2]->(friend:User)
-[p:PURCHASED]->(prod:Product)
WHERE p.purchasedAt >= datetime() - duration('P7D')
RETURN prod.name, COUNT(friend) AS friendsBought
ORDER BY friendsBought DESC
LIMIT 5Vérification rapide
Testez votre compréhension des concepts de MongoDB et des bases de données NoSQL présentés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que les bases de données en graphe comme Neo4j excellent dans les parcours relationnels profonds sur plusieurs sauts — moteurs de recommandation, détection de fraude et graphes de connaissances — là où les chaînes de $lookup de MongoDB se dégradent de façon exponentielle ; que le langage Cypher de Neo4j exprime les motifs de graphe de manière déclarative, d’une façon qu’aucun langage de requête documentaire ne peut égaler ; et que la persistance polyglotte, qui consiste à utiliser MongoDB pour les données documentaires et Neo4j pour parcourir les relations, est une architecture courante en production. Nous allons maintenant aborder le projet final : concevoir l’architecture d’une application MongoDB prête pour la production.
Apprends JavaScript avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « Quand utiliser une base de données graphe telle que Neo4j » est-elle gratuite ?
Oui — le texte complet de « Quand utiliser une base de données graphe telle que Neo4j » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours MongoDB Academy, passe à CoddyKit PRO. Le cours MongoDB Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Quand utiliser une base de données graphe telle que Neo4j » ?
Les apprenants identifieront les problèmes de nature graphique — moteurs de recommandation, détection des fraudes, graphes de connaissances — pour lesquels le parcours natif de Neo4j surpasse les cha… Tu pratiques MongoDB Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer MongoDB Academy ?
Aucune expérience préalable n'est requise. MongoDB Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Quand utiliser une base de données graphe telle que Neo4j » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon MongoDB Academy ?
Oui. Chaque leçon MongoDB Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- MongoDB ou Redis : documents ou cache clé-valeur
- MongoDB ou Cassandra : écritures à l’échelle planétaire
- MongoDB ou DynamoDB : compromis des solutions natives du cloud
- Quand utiliser une base de données graphe telle que Neo4j