Introduction : des données aux connexions
Microsoft Fabric unifie le data engineering, l'analytique et l'AI à travers l'écosystème Microsoft.
Mais de nombreux problèmes métier, comme la détection de fraude, le customer 360 ou l'optimisation de la supply chain, ne dépendent pas de points de données isolés, mais de la façon dont ces points se connectent.
Microsoft Fabric offre déjà aux organisations une base solide pour l'analytique, la gouvernance et l'AI, sur des données à la fois structurées et non structurées.
Mais dans le monde réel, tous les défis ne concernent pas des lignes isolées dans une table. Certains des problèmes les plus difficiles portent sur la façon dont les choses se connectent, les relations cachées à travers les systèmes, les transactions ou les interactions. C'est là qu'une approche graph apporte une réelle puissance.
Quelques exemples :
- Détecter la fraude: Les fraudeurs agissent rarement isolément. Ils exploitent des réseaux de comptes, d'appareils et de transactions. En suivant les liens, un graph peut révéler des boucles cachées ou des clusters d'activité inhabituels qu'il serait quasi impossible de repérer dans des rapports plats.
- Construire un véritable Customer 360 : Chaque client laisse une trace de signaux : un e-mail dans un système, un achat dans un autre, une carte de fidélité dans un troisième. Les graphs permettent d'assembler facilement ces fragments en une vue unique et connectée du client, favorisant une personnalisation et un service plus précis.
- Fournir des recommandations plus intelligentes: Qu'il s'agisse d'un film, d'un produit ou d'un service, les recommandations fonctionnent mieux lorsqu'elles reflètent de vraies connexions : « les gens qui ont aimé ceci ont aussi aimé cela » ou « des amis aux goûts similaires ». Les graphs capturent ces schémas naturellement et rendent transparent le raisonnement derrière les suggestions.
- Enrichir la GenAI avec du contexte: Les large language models sont puissants, mais ils ont besoin d'un ancrage dans des faits fiables. Un knowledge graph fournit ce contexte, garantissant que les réponses de la GenAI ne sont pas seulement fluides mais aussi exactes, explicables et connectées à la vérité de l'entreprise.
Les requêtes SQL traditionnelles peuvent exprimer ces schémas, mais elles deviennent lentes, complexes et difficiles à maintenir. Les bases de données graph sont conçues pour ce type d'analyse.
Avec le nouveau Neo4j Graph Workload pour Microsoft Fabric, les organisations peuvent désormais explorer des relations et des schémas complexes sans jamais quitter l'environnement Fabric.
Ce que le Neo4j Graph Workload apporte à Fabric
Le Neo4j Graph Workload s'exécute nativement dans Fabric en tant que managed workload, propulsé par Neo4j AuraDB.
Il vous permet de :
- Une connexion directe aux données du Fabric Lakehouse dans OneLake, minimisant les mouvements de données.
- Une modélisation de graph assistée par AI, qui suggère automatiquement les nodes, relations et propriétés.
- Une exploration interactive du graph, permettant aux utilisateurs de déployer les nodes et d'inspecter visuellement les relations.
- L'exécution de requêtes Cypher au sein de l'interface de requête de Fabric, pour explorer ou par exemple créer de nouvelles relations
- L'accès à 65 algorithmes graph de Neo4j, dont PageRank, Louvain et node similarity.
- Se connecter à l'AuraDB pour une transformation ultérieure via des notebooks
- Visualiser les résultats dans Power BI via BI Connector for AuraDB (Simba Technologies)
- Un contrôle d'accès basé sur Microsoft Entra ID et une intégration avec la gouvernance Fabric.
En bref : c'est Fabric, mais avec de l'intelligence relationnelle intégrée.
Un cas d'usage complet et pratique ci-dessous vous guide à travers chaque étape de l'exploration de ces capacités à l'aide d'un dataset de films dans OneLake, afin que vous puissiez suivre et en faire l'expérience vous-même.
Limites actuelles (public preview)
Comme il s'agit d'une public preview, il y a quelques lacunes à connaître :
- Un essai par tenant : seul le premier utilisateur peut lancer l'essai gratuit de 14 jours d'AuraDB.
Lorsqu'une personne dans un tenant Fabric lance l'essai gratuit de 14 jours d'AuraDB Professional, cela crée une instance Neo4j partagée (liée au workspace et à la région Fabric).
L'essai est limité au tenant : seul le premier utilisateur peut déclencher la création de cette instance.
Cependant, une fois créée, jusqu'à 10 utilisateurs peuvent se connecter simultanément au même Neo4j AuraDB graph workload via Fabric.
- Personnalisation du modèle : la modélisation de graph assistée par GenAI est automatique, mais vous ne pouvez pas actuellement modifier entièrement le schéma du graph avant le chargement, même si vous pouvez déjà changer beaucoup de choses.
- Writeback vers OneLake : aujourd'hui, les insights restent dans l'instance AuraDB ; les réécrire directement vers OneLake depuis l'interface Graph est prévu pour une future release.
- Pas de connexion native pour Power BI (pas de bouton « Open in Power BI » ni de flux de credentials Fabric, et non pris en charge par l'intégration d'identité de Fabric (Entra ID)) : il utilise toujours les credentials au niveau Aura.
Malgré ces limites, l'intégration est déjà fonctionnelle et suffisamment puissante pour le prototypage, les proofs of concept et les premiers scénarios de production.
Ce qui figure sur la roadmap
Microsoft et Neo4j ont annoncé plusieurs améliorations à venir qui renforceront encore l'intégration et amélioreront la facilité d'utilisation :
- Un designer de modèle de graph éditable, permettant aux utilisateurs de modifier entièrement les mappings de nodes et de relations avant le chargement des données.
- Un refresh de schéma et des options de synchronisation pour maintenir la vue Explorer à jour avec les changements dans AuraDB. (semble déjà OK à partir de novembre 2025)
- Write-back vers OneLake, permettant un round-tripping fluide des résultats du graph vers le Lakehouse pour l'analytique downstream et Power BI.
- Une intégration Power BI améliorée, supprimant le besoin du connecteur BI séparé.
- Des fonctionnalités AI étendues, prenant en charge des scénarios GraphRAG et embeddings plus avancés.
Modèle de tarification
Bien que la documentation public preview confirme un essai gratuit de 14 jours d'AuraDB Professional et montre un modèle de tarification pay-as-you-go pour AuraDB, le modèle de coût complet pour le Graph Workload dans Fabric, combinant l'abonnement AuraDB et l'utilisation de la capacité Fabric, est encore en cours de finalisation par Microsoft et Neo4j. Aucune documentation claire à ce sujet n'a été trouvée
Dans les coulisses : construire un univers cinématographique connecté dans Microsoft Fabric
Pour rendre le nouveau Neo4j Graph Workload plus concret, nous l'avons exploré avec un dataset simple mais familier : des données de films stockées dans OneLake.
Ce dataset contient des tables pour :
- Movies (titre, année de sortie, genre, etc.),
- Persons (acteurs, réalisateurs, producteurs)
- Users (personnes qui regardent les films)
- Roles (liens entre les personnes et les films dans lesquels elles ont joué, utilisateurs notant des films et suivant d'autres utilisateurs (friends)).
Dans une vue traditionnelle basée sur des tables, ces sources de données sont faciles à interroger pour des faits : par exemple « Dans quels films Tom Hanks a-t-il joué »
Mais dès que vous commencez à demander « Qui a tendance à jouer ensemble », « Quelles communautés d'acteurs existent », ou « Quels films peuvent être recommandés à certains utilisateurs », les jointures relationnelles deviennent complexes, inefficaces et difficiles à appréhender.
C'est exactement là que l'approche graph brille.
Explorons étape par étape. Vous verrez comment :
- Commencer dans Fabric: charger des données de films dans un Lakehouse.
Ici, vos données vivent encore dans des tables, le point de départ parfait pour l'analytique structurée. - Le transformer en graph: utiliser le Neo4j Graph Workload pour détecter automatiquement les entités et relations et transformer les données tabulaires en un modèle de graph.
- Analyser et enrichir le graph: explorer et analyser votre graph à l'aide du visual explorer et de requêtes Cypher, et utiliser des algorithmes de graph data science comme PageRank ou Louvain pour découvrir des communautés, des influenceurs ou des clusters de collaboration et réécrire de nouveaux insights.
- L'opérationnaliser : utiliser des notebooks Fabric pour transformer les insights en action : par exemple, générer des recommandations de films basées sur les amis à l'aide des relations de votre graph, et réécrire les résultats dans votre Lakehouse
- Le visualiser : donner vie à vos résultats dans Power BI, soit via une connexion directe à Neo4j AuraDB pour des visuels de graph en temps réel, soit via votre Lakehouse pour une analytique et des dashboards gouvernés.
Commencer dans Fabric
Ajouter le Neo4j Graph Workload
Dans votre workspace Fabric :
- Cliquez sur New Neo4j Graph Workload.
- Choisissez un nom pour votre workload et confirmez la région (elle doit correspondre à la région de votre capacité Fabric).
- Fabric se connecte à Neo4j AuraDB et crée automatiquement un essai gratuit de 14 jours d'AuraDB Professional lié à votre tenant.
- La configuration se termine en moins d'une minute et, dès lors, vous disposez d'une base de données graph Neo4j entièrement fonctionnelle, intégrée directement dans votre environnement Fabric.
Conseils :
- Si vous déployez Neo4j dans un nouveau tenant Fabric, assurez-vous d'abord qu'un principal Azure SQL Server existe. Lorsque nous avons tenté d'activer le Neo4j Graph Workload dans un tenant Fabric nouvellement créé, la configuration a échoué avec une erreur unauthorized. Cela s'est produit parce que le tenant n'avait pas de principal SQL Server existant, sur lequel Fabric s'appuie pour l'authentification sécurisée entre Fabric et l'instance managed AuraDB.
La création d'une ressource Azure SQL Server basique a immédiatement résolu le problème
- N'oubliez pas de copier le mot de passe que vous obtenez lors de la création de l'instance Neo4j, car vous en avez besoin pour vous connecter à l'AuraDB via un notebook ou Power BI avec l'utilisateur neo4j créé par défaut.
Cette instance est gérée par Fabric mais propulsée par Neo4j AuraDB, ce qui signifie que vous pouvez interroger, visualiser et analyser vos données sans quitter Fabric.
Charger et modéliser les données de films vers le lakehouse
Nous avons créé des données de films fictives dans des csv. Téléchargeables sur Github
Ces données, nous les avons chargées dans des delta tables dans un Lakehouse de notre Workspace Demo
Le transformer en graph
Créez d'abord un nouvel élément Neo4j Graph Dataset dans le workspace où vous avez ajouté le Neo4j graph workload.
Sélectionnez le lakehouse que vous avez créé avec les données de films et sélectionnez toutes les tables qu'il contient.
Grâce à la modélisation de graph assistée par GenAI dans le workload Fabric, les tables du lakehouse sont transformées en une structure de graph :
À ce stade, le modèle de graph a été généré, mais les données n'ont pas encore été chargées dans l'AuraDB. Vous pouvez encore explorer et affiner le modèle avant de le valider.
Si vous cliquez sur un node ou une relation, le panneau de droite indique à quelle table du lakehouse il est mappé et quelles propriétés ont été assignées.
Cela vous donne une vue claire de la façon dont vos données OneLake se traduiront en une structure de graph.
L'interface vous permet d'étendre le modèle avant le chargement :
- Pour ajouter un nouveau node, survolez le bord d'un node existant jusqu'à ce qu'une petite icône plus (+) apparaisse. Cliquer dessus crée un nouveau node dans le diagramme.
- Pour ajouter une nouvelle relation, faites glisser le nouveau node vers un node existant : une ligne de relation apparaîtra automatiquement.
Vous pouvez ensuite définir comment ce nouveau node ou cette relation se mappe à vos données source, en veillant à ce qu'il se connecte aux bonnes tables et champs et représente une relation logique au sein de votre domaine de données.
Par exemple, vous pouvez ajouter Country (un champ des tables movie et user) comme node et FILMED-IN, LIVED-IN comme nouvelles relations, comme illustré dans l'image ci-dessous :
Cette étape d'édition est utile si votre modèle de données évolue ou si vous souhaitez inclure des entités et relations supplémentaires.
Pour charger les données dans le graphDB, cliquez surTransform to graph
Analyser et enrichir le graph
Explorer votre graph visuellement
L'outil Explore, propulsé par Neo4j Bloom, vous permet d'interagir visuellement avec vos données graph, directement au sein de l'environnement Fabric.
Au lieu d'écrire des requêtes, vous pouvez rechercher des schémas, déployer des relations et styliser ou filtrer des nodes pour révéler des connexions cachées.
Explore transforme vos données en une vue réseau interactive, faisant remonter les relations dont vous soupçonniez déjà l'existence et en révélant de nouvelles que vous n'auriez peut-être jamais remarquées.
C'est une manière intuitive de voir le contexte : comment les utilisateurs, les films et les acteurs se connectent, se regroupent ou s'influencent mutuellement.
Le manuel d'utilisation de cette fonctionnalité se trouve ici
Interroger votre graph
Vous pouvez aussi explorer vos données de manière programmatique avec Cypher, le puissant langage de requête graph de Neo4j.
Depuis le bouton Query dans le ruban Fabric, vous pouvez écrire, exécuter et visualiser des requêtes Cypher directement sur votre graph dataset.
L'outil Query se concentre sur trois capacités clés :
- Écrire et exécuter des requêtes Cypher pour naviguer, filtrer et analyser votre graph.
- Consulter et réécrire les résultats sous forme de nouveaux nodes ou relations
- Visualiser les résultats de requêtes qui incluent des entités graph telles que des nodes, des relations ou des chemins complets.
Lorsque votre requête renvoie des structures graph, Fabric bascule automatiquement vers la Graph View,
Si votre requête ne renvoie que des valeurs scalaires (comme des noms, des comptages ou des métriques), l'outil les affiche plutôt en Table View.
Exemple 1 : requête agrégée (Table View)
Cette requête compte dans combien de films chaque acteur est apparu.
Comme elle ne renvoie que des valeurs scalaires, elle sera affichée en Table View :
MATCH (p:Person)-[:ACTS_IN]->(m:Movie)
RETURN p.name AS actor, count(m) AS movies
ORDER BY movies DESC
LIMIT 50;
Ce qu'elle montre :
Une liste classée des 50 acteurs les plus actifs, y compris le nombre de films dans lesquels chacun est apparu.
Exemple 2 : requête de relation (Graph View)
Cette requête trouve les acteurs qui ont partagé l'affiche avec Sam Monroe et visualise le réseau de collaboration.
Comme elle renvoie à la fois des nodes et et des relations, les résultats apparaissent en Graph View
MATCH (a:Person {name: "Sam Monroe"})-[r1:ACTS_IN]->(m:Movie)<-[r2:ACTS_IN]-(co:Person)
RETURN a, r1, m, r2, co
LIMIT 50;
Ce qu'elle montre :
Un graph interactif où Sam Monroe est connecté aux films dans lesquels il a joué, et ces films renvoient à tous les autres acteurs qui y sont apparus à ses côtés.
La visualisation met en évidence les schémas de collaboration : par exemple, quels acteurs jouent souvent aux côtés de Sam Monroe ou quels films servent de ponts entre différents cercles d'acteurs.
Utiliser la Graph Data Science sur le graph des films
Une fois vos données de films dans Neo4j, la Graph Data Science (GDS) vous permet d'aller au-delà de l'exploration pour mesurer l'influence, trouver des communautés et faire ressortir la similarité, puis de réécrire ces insights pour la recherche, le style et la logique applicative.
Ce que vous pouvez faire avec les données de films par exemple :
- Communautés (Louvain / LPA) : découvrir des ensembles d'acteurs qui partagent souvent l'affiche (équipes de genre, équipes de réalisateurs récurrentes).
- Influence (PageRank / Betweenness) : trouver des acteurs-ponts qui relient les clusters (idéal pour le casting ou le ciblage promotionnel).
- Similarité (Node Similarity / Jaccard) : suggérer de nouvelles collaborations (« des gens comme vous partagent l'affiche avec »), ou des lookalikes user-user/movie-movie.
- Connectivité (WCC) : identifier des sous-graphs isolés (par ex. des festivals de niche ou des poches de cinéma régional).
- Chemins (requêtes k-hop) : tracer des chaînes de collaboration (« comment l'Acteur A est-il connecté à l'Acteur B »).
Nous avons essayé l'algorithme Louvain
- dans le visual explorer
- dans l'outil query :
– matérialiser un réseau de co-acting dans l'outil query
exécuter la détection de communautés
réécrire des propriétés vers le graph pour une utilisation dans Explorer, Cypher ou des notebooks downstream.
Explorer le graph dans le visual explorer
Rechercher des communautés d'acteurs jouant régulièrement ensemble et donner une couleur différente à chaque communauté.
Voir manuel d'utilisation
Matérialiser un réseau de co-acting dans l'outil query
Cette requête relie les points entre les acteurs apparus dans le même film. Elle commence par trouver chaque paire de personnes (p1, p2) ayant joué ensemble dans un film (m).
Pour éviter les doublons (comme créer à la fois A-B et B-A), elle ne conserve qu'une seule direction : la personne avec l'ID interne le plus bas pointe vers celle avec l'ID le plus élevé.
Pour chaque paire de co-acteurs, elle collecte :
- movies : la liste des films qu'ils partagent,
- weight : combien de fois ils ont travaillé ensemble,
- firstYear et last year : quand ils sont apparus ensemble pour la première et la dernière fois.
Ensuite, elle crée ou met à jour une relation (:Person)-:CO_ACTED_WITH-(:Person) entre eux et stocke ces détails comme propriétés.
Le résultat est un réseau acteur-à-acteur direct que vous pouvez analyser, styliser et visualiser. Au lieu de sauter à chaque fois de film en film, vous disposez désormais d'un graph compact qui montre directement la force de collaboration entre acteurs.
// Create one directed edge per pair (deterministic: lower id -> higher id)
MATCH (m:Movie)<-[:ACTS_IN]-(p1:Person),
(m)<-[:ACTS_IN]-(p2:Person)
WHERE ElementId(p1) < ElementId(p2)
WITH p1, p2, collect(m) AS movies, count(*) AS weight,
min(m.year) AS firstYear, max(m.year) AS lastYear
MERGE (p1)-[r:CO_ACTED_WITH]->(p2)
SET r.weight = weight,
r.titles = [m IN movies | m.title],
r.firstYear = firstYear,
r.lastYear = lastYear;
Projeter le graph vers GDS et exécuter des algorithmes
Projetez la couche Person avec CO_ACTED_WITH comme relation non orientée et une propriété weight
CALL gds.graph.drop('coacting', false); // ignore if it doesn't exist
CALL gds.graph.project(
'coacting',
'Person',
{
CO_ACTED_WITH: {
orientation: 'UNDIRECTED',
properties: 'weight'
}
}
);
Détection de communautés (Louvain) : réécriture vers les nodes
CALL gds.louvain.write(
'coacting',
{
relationshipWeightProperty: 'weight',
writeProperty: 'communityId'
}
)
YIELD communityCount, modularity, modularities;
Désormais, chaque (:Person) possède un communityId, que vous pouvez utiliser pour colorer les nodes dans le visual Explorer ou filtrer dans Cypher/Power BI.
Visualiser et interroger les résultats
Avec communityId et (optionnellement) pagerank écrits, vous pouvez immédiatement styliser et filtrer dans Explore (Bloom dans Fabric) :
- Colorer par communityId pour révéler les ensembles.
L'opérationnaliser : utilisation ultérieure des GraphData via des notebooks
Une étape naturelle après l'exécution de vos algorithmes graph consiste à transformer ces insights en données sur lesquelles vous pouvez agir.
Prenons l'exemple des recommandations de films. À l'aide du graph social (User)-:FOLLOWS-(User)-:RATES-(Movie), vous pouvez calculer quels films les amis de confiance d'un utilisateur notent bien et générer une liste de titres suggérés qu'ils n'ont pas encore vus.
Au sein de Neo4j, ces résultats pourraient être représentés comme de nouvelles relations : par exemple (u)-:RECOMMENDED-(m), ou stockés comme propriétés de node. C'est idéal pour l'analytique graph exploratoire, où vous voulez garder visible le contexte de connectivité complet et continuer à affiner vos algorithmes.
Cependant, une fois les recommandations prêtes pour une consommation plus large, il est souvent plus pratique de les réécrire vers le Fabric Lakehouse :
- Dans Fabric, vous pouvez facilement joindre les recommandations à d'autres datasets (par ex. profils utilisateurs, historique de visionnage, segments marketing).
- Les data engineers peuvent alimenter les résultats dans des pipelines, en les faisant remonter vers des rapports BI, des dashboards ou des API de personnalisation.
- Vous pouvez versionner, gouverner et partager les données dérivées aux côtés d'autres actifs de données d'entreprise.
En bref, le graph vous offre la découverte, la compréhension de schémas difficiles à exprimer en SQL, tandis que le Lakehouse vous donne la possibilité d'opérationnaliser et de réutiliser ces insights à travers l'analytique, le ML et les applications.
Par exemple, après avoir généré des recommandations de films basées sur les amis dans Neo4j, vous pourriez exporter les 5 meilleurs titres par utilisateur vers une Delta table de votre Lakehouse. Power BI peut ensuite les visualiser sous forme de dashboards « Recommended for You », ou Synapse ML peut entraîner un modèle de ranking par-dessus.
Le notebook de recommandation basé sur les amis
Pour opérationnaliser cette logique, nous avons construit un notebook Fabric qui calcule les 5 meilleures recommandations de films basées sur les amis par utilisateur et les écrit sous forme de table structurée.
- Se connecter à Neo4j AuraDB
Le notebook utilise le driver Python officiel de Neo4j pour se connecter en toute sécurité à votre instance Aura. Utilisez le mot de passe que vous avez obtenu lors de l'ajout du Neo4j Graph workload. - Exécuter la logique Cypher
Pour chaque utilisateur, il :- Trouve les amis et les films qu'ils ont notés.
- Exclut les films que l'utilisateur a déjà notés.
- Calcule la note moyenne des amis et le nombre de votes.
- Renvoie les 5 meilleurs films par utilisateur.
- Transformer avec Pandas
Les résultats sont rassemblés dans un DataFrame, classés par utilisateur et enrichis d'une colonne rank. - Écrire vers Delta / Lakehouse
Enfin, le notebook enregistre le dataset dans
Tables/neo4j_movies_recs_friends, soit sous forme de Delta table (dans Fabric), soit sous forme de fichier Parquet (si Spark n'est pas disponible) : - write_delta(recs, “neo4j_movies_recs_friends”)
# Welcome to your new notebook
# Type here in the cell editor to add code!
# =============================
# Friends-based recommendations (RATES / ACTS-IN)
# Writes: Tables/neo4j_movies_recs_friends
# =============================
%pip install --quiet neo4j~=5.28.0 pandas~=2.2.2
from neo4j import GraphDatabase
import pandas as pd
# ---- AuraDB config ----
AURA_URI = "neo4j+s://<YOURINSTANCE>.databases.neo4j.io"
AURA_USER = "neo4j"
AURA_PASSWORD = "<YOURPASSWORD>"
WRITE_MODE = "overwrite" # or "append"
# If your data model uses different labels/properties, adjust here:
# Model-specific names (adjust if needed)
USER_LABEL = "User"
MOVIE_LABEL = "Movie"
FOLLOWS_REL = "FOLLOWS"
RATES_REL = "RATES" # per your graph
RATING_PROPERTY = "rating" # property on RATES
TOP_N_PER_USER = 5
def run_df(query: str, params: dict | None = None) -> pd.DataFrame:
with GraphDatabase.driver(AURA_URI, auth=(AURA_USER, AURA_PASSWORD)) as driver:
with driver.session() as session:
return pd.DataFrame(session.run(query, params or {}).data())
def write_delta(df: pd.DataFrame, table_path: str, mode: str = "overwrite"):
if df is None or df.empty:
print(f"[WARN] No data for {table_path}; nothing written.")
return
try:
spark # Fabric Spark available?
sdf = spark.createDataFrame(df)
sdf.write.format("delta").mode(mode).save(f"Tables/{table_path}")
print(f"[OK] Wrote Delta: Tables/{table_path} (rows: {len(df)})")
except NameError:
fp = f"/mnt/data/{table_path}.parquet"
df.to_parquet(fp, index=False)
print(f"[OK] No Spark; wrote Parquet: {fp} (rows: {len(df)})")
# Connectivity (optional)
ver = run_df("CALL dbms.components() YIELD name, versions RETURN versions[0] AS version")
print(f"[OK] Connected to Neo4j {ver.iloc[0]['version'] if not ver.empty else 'unknown'}")
# ---- Cypher: variable-scoped subquery without returning `u` ----
cypher = f"""
MATCH (u:{USER_LABEL})
CALL (u) {{
WITH u
MATCH (u)-[:{FOLLOWS_REL}]->(f:{USER_LABEL})-[r:{RATES_REL}]->(m:{MOVIE_LABEL})
WHERE NOT (u)-[:{RATES_REL}]->(m)
WITH m,
avg(coalesce(r.{RATING_PROPERTY}, 0.0)) AS score,
count(*) AS votes
ORDER BY score DESC, votes DESC, m.title ASC
LIMIT $top
RETURN m.title AS movie, score, votes
}}
RETURN u.name AS user, movie, score, votes
ORDER BY user ASC, score DESC, votes DESC, movie ASC
"""
recs = run_df(cypher, {"top": TOP_N_PER_USER})
# Rank per user (1..TOP_N_PER_USER)
if not recs.empty:
recs["rank"] = recs.groupby("user", sort=False).cumcount() + 1
write_delta(recs, "neo4j_movies_recs_friends")
Visualiser les insights du graph dans Power BI
Power BI peut se connecter directement à Neo4j AuraDB à l'aide du Neo4j BI Connector (ODBC/JDBC).
Ce connecteur traduit les résultats de requêtes Cypher en une couche SQL virtuelle, permettant à Power BI d'interroger les données graph comme si elles étaient relationnelles, tout en conservant la vitesse et la flexibilité du parcours de graph.
Installez le Neo4j BI Connector depuis le Neo4j Download Center
L'authentification se fait avec l'utilisateur par défaut neo4j et le mot de passe que vous avez copié lorsque vous avez créé pour la première fois un Neo4j graphDB
Construisez instantanément des dashboards à partir de vues graph, comme des réseaux acteur-film, des classements d'influenceurs ou des clusters de similarité.
Cette configuration contourne pour l'instant l'UI du Fabric Graph Workload et se connecte directement à l'instance AuraDB sous-jacente.
Elle est stable, prête pour la production et idéale lorsque vous voulez des dashboards Power BI interactifs sur des données graph.
À PROPOS DE L'AUTEUR
An De Lafonteyne
Managing Partner BE-Flanders
