Inleiding: van data naar connecties
Microsoft Fabric verenigt data engineering, analytics en AI over het Microsoft-ecosysteem heen.
Maar veel businessproblemen, zoals fraudedetectie, customer 360 en supply-chain-optimalisatie, hangen niet af van afzonderlijke datapunten, maar van hoe die punten met elkaar verbonden zijn.
Microsoft Fabric geeft organisaties al een sterk fundament voor analytics, governance en AI, over zowel gestructureerde als ongestructureerde data heen.
Maar in de echte wereld draait niet elke uitdaging om afzonderlijke rijen in een tabel. Sommige van de lastigste problemen gaan over hoe dingen met elkaar verbonden zijn, de relaties die verborgen zitten in systemen, transacties of interacties. Daar voegt een graph-aanpak echte kracht toe.
Enkele voorbeelden:
- Fraude blootleggen: Fraudeurs handelen zelden geïsoleerd. Ze buiten netwerken van accounts, apparaten en transacties uit. Door de links te volgen, kan een graph verborgen loops of ongewone clusters van activiteit onthullen die vrijwel onmogelijk op te sporen zijn in platte rapporten.
- Een echte Customer 360 bouwen: Elke klant laat een spoor van signalen achter: een e-mail in het ene systeem, een aankoop in een ander, een loyaltykaart in een derde. Graphs maken het eenvoudig om deze fragmenten aan elkaar te rijgen tot één samenhangend beeld van de klant, wat nauwkeurigere personalisatie en dienstverlening mogelijk maakt.
- Slimmere aanbevelingen leveren: Of het nu om een film, een product of een dienst gaat: aanbevelingen werken het best wanneer ze echte connecties weerspiegelen: 'mensen die dit leuk vonden, vonden dat ook leuk' of 'vrienden met vergelijkbare smaak'. Graphs vatten deze patronen op een natuurlijke manier en maken de redenering achter suggesties transparant.
- GenAI verrijken met context: Large language models zijn krachtig, maar ze hebben verankering in betrouwbare feiten nodig. Een knowledge graph biedt die context en zorgt ervoor dat GenAI-antwoorden niet alleen vloeiend zijn, maar ook accuraat, verklaarbaar en verbonden met de enterprise-waarheid.
Traditionele SQL-queries kunnen deze patronen uitdrukken, maar ze worden traag, complex en moeilijk te onderhouden. Graphdatabases zijn ontworpen voor dit type analyse.
Met de nieuwe Neo4j Graph Workload voor Microsoft Fabric kunnen organisaties nu complexe relaties en patronen verkennen zonder ooit de Fabric-omgeving te verlaten.
Wat de Neo4j Graph Workload aan Fabric toevoegt
De Neo4j Graph Workload draait natively in Fabric als een managed workload, aangedreven door Neo4j AuraDB.
Ze laat je toe om:
- Rechtstreekse verbinding met Fabric Lakehouse-data in OneLake, wat dataverplaatsing minimaliseert.
- AI-ondersteunde graph modeling, die automatisch nodes, relaties en properties voorstelt.
- Interactieve graph-exploratie, waarmee gebruikers nodes kunnen uitklappen en relaties visueel kunnen inspecteren.
- Uitvoering van Cypher-queries binnen de query-interface van Fabric, om te verkennen of bijvoorbeeld nieuwe relaties aan te maken
- Toegang tot 65 Neo4j graph-algoritmen, waaronder PageRank, Louvain en node similarity.
- Verbinden met de AuraDB voor verdere transformatie via notebooks
- Resultaten visualiseren in Power BI via BI Connector for AuraDB (Simba Technologies)
- Toegangsbeheer op basis van Microsoft Entra ID en integratie met Fabric-governance.
Kortom: het is Fabric, maar met relatie-intelligentie ingebouwd.
Een volledige, praktische use case hieronder loodst je door elke stap van het verkennen van deze mogelijkheden met een filmdataset in OneLake, zodat je kunt meevolgen en het zelf kunt ervaren.
Huidige beperkingen (public preview)
Aangezien dit een public previewis, zijn er enkele hiaten om rekening mee te houden:
- Eén trial per tenant: alleen de eerste gebruiker kan de gratis AuraDB-trial van 14 dagen starten.
Wanneer één persoon in een Fabric-tenant de gratis AuraDB Professional-trial van 14 dagen start, creëert dat één gedeelde Neo4j-instance (gekoppeld aan de Fabric-workspace en -regio).
De trial is tenant-scoped: alleen de eerste gebruiker kan de aanmaak van die instance triggeren.
Zodra ze echter is aangemaakt, kunnen tot 10 gebruikers gelijktijdig verbinding maken met dezelfde Neo4j AuraDB graph workload via Fabric.
- Modelaanpassing: de GenAI-ondersteunde graph modeling is automatisch, maar momenteel kun je het graph-schema niet volledig bewerken voor het laden, hoewel je al veel kunt wijzigen.
- Writeback naar OneLake: vandaag blijven de inzichten binnen de AuraDB-instance; ze rechtstreeks vanuit de Graph-interface terugschrijven naar OneLake is gepland voor een toekomstige release.
- Geen native verbinding voor Power BI (geen 'Open in Power BI'-knop of Fabric credential flow, en niet ondersteund door de identiteitsintegratie van Fabric (Entra ID)): het gebruikt nog steeds de credentials op Aura-niveau.
Ondanks deze beperkingen is de integratie al functioneel en krachtig genoeg voor prototyping, proof-of-concepts en vroege productiescenario's.
Wat op de roadmap staat
Microsoft en Neo4j hebben verschillende komende verbeteringen aangekondigd die de integratie verder zullen aanscherpen en de bruikbaarheid zullen verbeteren:
- Bewerkbare graph model designer, waarmee gebruikers node- en relatiemappings volledig kunnen aanpassen voor het laden van data.
- Schema refresh en synchronisatie-opties om de Explorer-view up-to-date te houden met wijzigingen in AuraDB. (lijkt al in orde te zijn vanaf nov 2025)
- Write-back naar OneLake, wat naadloze round-tripping van graph-resultaten naar het Lakehouse mogelijk maakt voor downstream analytics en Power BI.
- Verbeterde Power BI-integratie, die de nood aan de aparte BI-connector wegneemt.
- Uitgebreide AI-features, die meer geavanceerde GraphRAG- en embeddings-scenario's ondersteunen.
Prijsmodel
Hoewel de public preview-documentatie een gratis AuraDB Professional-trial van 14 dagen bevestigt en een pay-as-you-go-prijsmodel toont voor AuraDB, wordt het volledige kostenmodel voor de Graph Workload in Fabric, dat AuraDB-abonnement en Fabric-capaciteitsgebruik combineert, nog gefinaliseerd door Microsoft en Neo4j. Er werd geen duidelijke documentatie hierover gevonden
Achter de schermen: een verbonden filmuniversum bouwen in Microsoft Fabric
Om de nieuwe Neo4j Graph Workload tastbaarder te maken, verkenden we ze met een eenvoudige maar vertrouwde dataset: filmdata opgeslagen in OneLake.
Deze dataset bevat tabellen voor:
- Movies (titel, releasejaar, genre, enz.),
- Persons (acteurs, regisseurs, producers)
- Users (mensen die de films bekijken)
- Roles (links tussen mensen en de films waarin ze speelden, gebruikers die films beoordelen en andere gebruikers volgen (friends)).
In een traditionele tabelgebaseerde view zijn deze databronnen eenvoudig te bevragen voor feiten: bijvoorbeeld 'In welke films speelde Tom Hanks'
Maar op het moment dat je begint te vragen 'Wie speelt vaak samen', 'Welke acteurgemeenschappen bestaan er', of 'Welke films kunnen worden aanbevolen aan bepaalde gebruikers', worden relationele joins complex, inefficiënt en moeilijk te doorgronden.
Dit is precies waar de graph-aanpak schittert.
Laten we stap voor stap verkennen. Je zult zien hoe je:
- Start in Fabric: Laad filmdata in een Lakehouse.
Hier leeft je data nog in tabellen, het perfecte startpunt voor gestructureerde analytics. - Zet het om in een graph: Gebruik de Neo4j Graph Workload om automatisch entiteiten en relaties te detecteren en tabeldata om te vormen tot een graph-model.
- Analyseer en verrijk de graph: Verken en analyseer je graph met de visual explorer en Cypher-queries en gebruik graph data science-algoritmen zoals PageRank of Louvain om communities, influencers of samenwerkingsclusters te ontdekken en nieuwe inzichten terug te schrijven.
- Operationaliseer het : Gebruik Fabric-notebooks om inzichten om te zetten in actie: genereer bijvoorbeeld filmaanbevelingen op basis van vrienden met de relaties in je graph, en schrijf de resultaten terug naar je Lakehouse
- Visualiseer het : Breng je resultaten tot leven in Power BI, ofwel via een rechtstreekse verbinding met Neo4j AuraDB voor realtime graph-visuals, ofwel via je Lakehouse voor gegovernde analytics en dashboards.
Start in Fabric
De Neo4j Graph Workload toevoegen
In je Fabric-workspace:
- Klik op New Neo4j Graph Workload.
- Kies een naam voor je workload en bevestig de regio (die moet overeenkomen met de regio van je Fabric-capaciteit).
- Fabric maakt verbinding met Neo4j AuraDB en creëert automatisch een gratis AuraDB Professional-trial van 14 dagen, gekoppeld aan je tenant.
- De setup is in minder dan een minuut klaar en vanaf dan heb je een volledig functionele Neo4j-graphdatabase, rechtstreeks geïntegreerd in je Fabric-omgeving.
Tips:
- Als je Neo4j in een nieuwe Fabric-tenant uitrolt, zorg er dan eerst voor dat er een Azure SQL Server-principal bestaat. Toen we de Neo4j Graph Workload probeerden in te schakelen in een nieuw aangemaakte Fabric-tenant, faalde de setup met een unauthorized-fout. Dit gebeurde omdat de tenant geen bestaande SQL Server-principal had, waarop Fabric vertrouwt voor veilige authenticatie tussen Fabric en de managed AuraDB-instance.
Het aanmaken van een basale Azure SQL Server-resource loste het probleem onmiddellijk op
- Vergeet niet het wachtwoord te kopiëren dat je krijgt bij het aanmaken van de Neo4j-instance, want je hebt het nodig om verbinding te maken met de AuraDB via notebook of Power BI met de standaard aangemaakte gebruiker neo4j.
Deze instance wordt beheerd door Fabric maar aangedreven door Neo4j AuraDB, wat betekent dat je je data kunt bevragen, visualiseren en analyseren zonder Fabric te verlaten.
Filmdata laden en modelleren naar het lakehouse
We creëerden wat dummy-filmdata in csv's. Downloadbaar op Github
Deze data hebben we in delta tables geladen in een Lakehouse in onze Workspace Demo
Zet het om in een graph
Maak eerst een nieuw item Neo4j Graph Dataset aan in de workspace waar je de Neo4j graph workload hebt toegevoegd.
Selecteer het lakehouse dat je met de filmdata hebt aangemaakt en selecteer alle tabellen daarin.
Met de GenAI-ondersteunde graph modeling in de Fabric-workload worden de lakehouse-tabellen omgevormd tot een graph-structuur:
In dit stadium is het graph-model gegenereerd, maar de data is nog niet in de AuraDB geladen. Je kunt het model nog verkennen en verfijnen voor je het vastlegt.
Als je op een node of een relatie klikt, toont het paneel rechts aan welke lakehouse-tabel ze is gekoppeld en welke properties zijn toegewezen.
Dit geeft je een duidelijk beeld van hoe je OneLake-data zich zal vertalen naar een graph-structuur.
De interface laat je toe het model uit te breiden voor het laden:
- Om een nieuwe node toe te voegen, beweeg je over de rand van een bestaande node tot er een klein plus-icoon (+) verschijnt. Erop klikken creëert een nieuwe node in het diagram.
- Om een nieuwe relatie toe te voegen, sleep je de nieuwe node naar een bestaande: er verschijnt automatisch een relatielijn.
Vervolgens kun je definiëren hoe deze nieuwe node of relatie zich verhoudt tot je brondata, zodat ze verbindt met de juiste tabellen en velden en een logische relatie binnen je datadomein voorstelt.
Je kunt bijvoorbeeld Country (een veld van de tabel movie en user) toevoegen als een node en FILMED-IN, LIVED-IN als nieuwe relaties, zoals getoond in onderstaande afbeelding:
Deze bewerkstap is nuttig als je datamodel evolueert of als je extra entiteiten en relaties wilt opnemen.
Om de data in de graphDB te laden, klik je opTransform to graph
Analyseer en verrijk de graph
Je graph visueel verkennen
De Explore-tool, aangedreven door Neo4j Bloom, laat je visueel interageren met je graph-data, rechtstreeks binnen de Fabric-omgeving.
In plaats van queries te schrijven, kun je zoeken naar patronen, relaties uitklappen en nodes stylen of filteren om verborgen connecties bloot te leggen.
Explore verandert je data in een interactieve netwerkview, brengt de relaties naar boven waarvan je al vermoedde dat ze bestonden, en onthult nieuwe die je misschien nooit hebt opgemerkt.
Het is een intuïtieve manier om context te zien: hoe gebruikers, films en acteurs verbinden, clusteren of elkaar beïnvloeden.
De handleiding van deze functionaliteit vind je hier
Je graph bevragen
Je kunt je data ook programmatisch verkennen met Cypher, de krachtige graph-querytaal van Neo4j.
Vanuit de Query-knop in het Fabric-lint kun je Cypher-queries rechtstreeks tegen je graph-dataset schrijven, uitvoeren en visualiseren.
De Query-tool richt zich op drie kernmogelijkheden:
- Cypher-queries schrijven en uitvoeren om door je graph te navigeren, te filteren en te analyseren.
- Resultaten bekijken en terugschrijven als nieuwe nodes of relaties
- Queryresultaten visualiseren die graph-entiteiten bevatten, zoals nodes, relaties of volledige paden.
Wanneer je query graph-structuren retourneert, schakelt Fabric automatisch over naar de Graph View,
Als je query alleen scalaire waarden retourneert (zoals namen, tellingen of metrics), toont de tool ze in plaats daarvan in Table View.
Voorbeeld 1: geaggregeerde query (Table View)
Deze query telt in hoeveel films elke acteur is verschenen.
Omdat ze alleen scalaire waarden retourneert, wordt ze in Table View getoond:
MATCH (p:Person)-[:ACTS_IN]->(m:Movie)
RETURN p.name AS actor, count(m) AS movies
ORDER BY movies DESC
LIMIT 50;
Wat het toont:
Een gerangschikte lijst van de 50 meest actieve acteurs, inclusief in hoeveel films elk is verschenen.
Voorbeeld 2: relatiequery (Graph View)
Deze query vindt acteurs die samen met Sam Monroe hebben gespeeld en visualiseert het samenwerkingsnetwerk.
Omdat ze zowel nodes en als relaties retourneert, verschijnen de resultaten in 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;
Wat het toont:
Een interactieve graph waarin Sam Monroe verbonden is met de films waarin die heeft gespeeld, en die films linken naar alle andere acteurs die ernaast verschenen.
De visualisatie licht samenwerkingspatronen uit: bijvoorbeeld welke acteurs vaak samen met Sam Monroe spelen, of welke films als bruggen dienen tussen verschillende acteurskringen.
Graph Data Science gebruiken op de films-graph
Zodra je filmdata in Neo4j staat, laat Graph Data Science (GDS) je verder gaan dan exploratie om invloed te meten, communities te vinden en gelijkenis naar boven te halen, en die inzichten terug te schrijven voor zoeken, styling en app-logica.
Wat je bijvoorbeeld met de filmdata kunt doen:
- Communities (Louvain / LPA): ontdek acteurensembles die vaak samen spelen (genrecrews, terugkerende regisseursteams).
- Invloed (PageRank / Betweenness): vind brugacteurs die clusters verbinden (ideaal voor casting of promotietargeting).
- Gelijkenis (Node Similarity / Jaccard): stel nieuwe samenwerkingen voor ('mensen zoals jij spelen samen met'), of user-user/movie-movie-lookalikes.
- Verbondenheid (WCC): identificeer geïsoleerde subgraphs (bv. nichefestivals of regionale filmpockets).
- Paden (k-hop-queries): traceer samenwerkingsketens ('hoe is Actor A verbonden met Actor B').
We probeerden het Louvain-algoritme
- in de visual explorer
- in de query tool:
– een co-acting-netwerk materialiseren in de query tool
community-detectie uitvoeren
properties terugschrijven naar de graph voor gebruik in Explorer, Cypher of downstream notebooks.
Graph verkennen in de visual explorer
Op zoek naar communities van acteurs die regelmatig samen spelen en elke community een andere kleur geven.
Zie handleiding
Een co-acting-netwerk materialiseren in de query tool
Deze query verbindt de punten tussen acteurs die in dezelfde film zijn verschenen. Ze begint met het vinden van elk paar mensen (p1, p2) die samen in een film (m) speelden.
Om duplicaten te vermijden (zoals het aanmaken van zowel A-B als B-A), houdt ze slechts één richting aan: de persoon met de lagere interne ID wijst naar die met de hogere ID.
Voor elk paar co-acteurs verzamelt ze:
- movies: de lijst van films die ze delen,
- weight: hoe vaak ze hebben samengewerkt,
- firstYear en last year: wanneer ze voor het eerst en het laatst samen verschenen.
Vervolgens creëert of update ze een relatie (:Person)-:CO_ACTED_WITH-(:Person) tussen hen en slaat die details op als properties.
Het resultaat is een direct acteur-tot-acteur-netwerk dat je kunt analyseren, stylen en visualiseren. In plaats van telkens door films te springen, heb je nu een compacte graph die de samenwerkingssterkte tussen acteurs rechtstreeks toont.
// 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;
De graph projecteren naar GDS en algoritmen uitvoeren
Projecteer de Person-laag met CO_ACTED_WITH als een ongerichte relatie en een weight-property
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'
}
}
);
Community-detectie (Louvain): terugschrijven naar nodes
CALL gds.louvain.write(
'coacting',
{
relationshipWeightProperty: 'weight',
writeProperty: 'communityId'
}
)
YIELD communityCount, modularity, modularities;
Nu heeft elke (:Person) een communityId, die je kunt gebruiken om nodes te kleuren in de visual Explorer of te filteren in Cypher/Power BI.
De resultaten visualiseren en bevragen
Met communityId en (optioneel) pagerank weggeschreven, kun je onmiddellijk stylen en filteren in Explore (Bloom in Fabric):
- Kleuren op communityId om ensembles te onthullen.
Operationaliseer het : Verder gebruik van GraphData via notebooks
Een natuurlijke volgende stap na het uitvoeren van je graph-algoritmen is die inzichten omzetten in data waarmee je kunt handelen.
Neem het voorbeeld van filmaanbevelingen. Met de sociale graph (User)-:FOLLOWS-(User)-:RATES-(Movie) kun je berekenen welke films de vertrouwde vrienden van een gebruiker hoog beoordelen en een lijst van gesuggereerde titels genereren die ze nog niet hebben gezien.
Binnen Neo4j kunnen die resultaten worden voorgesteld als nieuwe relaties: bijvoorbeeld (u)-:RECOMMENDED-(m), of opgeslagen als node-properties. Dit is ideaal voor exploratieve graph analytics, waarbij je de volledige connectiviteitscontext zichtbaar wilt houden en je algoritmen wilt blijven verfijnen.
Zodra de aanbevelingen echter klaar zijn voor breder gebruik, is het vaak praktischer om ze terug te schrijven naar het Fabric Lakehouse:
- In Fabric kun je aanbevelingen eenvoudig joinen met andere datasets (bv. gebruikersprofielen, kijkgeschiedenis, marketingsegmenten).
- Data engineers kunnen de resultaten in pijplijnen voeden en ze zichtbaar maken in BI-rapporten, dashboards of personalisatie-API's.
- Je kunt de afgeleide data versioneren, governen en delen naast andere enterprise-data-assets.
Kortom, de graph geeft je ontdekking, het begrijpen van patronen die moeilijk in SQL uit te drukken zijn, terwijl het Lakehouse je de mogelijkheid geeft om die inzichten te operationaliseren en te hergebruiken over analytics, ML en applicaties heen.
Zo kun je bijvoorbeeld, na het genereren van filmaanbevelingen op basis van vrienden in Neo4j, de top 5 titels per gebruiker exporteren naar een Delta table in je Lakehouse. Power BI kan ze dan visualiseren als 'Recommended for You'-dashboards, of Synapse ML kan er een ranking-model bovenop trainen.
Het aanbevelingsnotebook op basis van vrienden
Om deze logica te operationaliseren, bouwden we een Fabric-notebook dat top 5 filmaanbevelingen op basis van vrienden per gebruiker berekent en ze wegschrijft als een gestructureerde tabel.
- Verbinden met Neo4j AuraDB
Het notebook gebruikt de officiële Neo4j Python-driver om veilig verbinding te maken met je Aura-instance. Gebruik het wachtwoord dat je kreeg bij het toevoegen van de Neo4j Graph workload. - De Cypher-logica uitvoeren
Voor elke gebruiker:- Vindt vrienden en de films die ze beoordeelden.
- Sluit films uit die de gebruiker al beoordeelde.
- Berekent de gemiddelde vriendbeoordeling en het aantal stemmen.
- Retourneert de top 5 films per gebruiker.
- Transformeren met Pandas
De resultaten worden verzameld in een DataFrame, gerangschikt per gebruiker en verrijkt met een rank-kolom. - Wegschrijven naar Delta / Lakehouse
Ten slotte slaat het notebook de dataset op in
Tables/neo4j_movies_recs_friends, ofwel als een Delta table (in Fabric), ofwel als een Parquet-bestand (als Spark niet beschikbaar is): - 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")
Graph-inzichten visualiseren in Power BI
Power BI kan rechtstreeks verbinding maken met Neo4j AuraDB via de Neo4j BI Connector (ODBC/JDBC).
Deze connector vertaalt Cypher-queryresultaten naar een virtuele SQL-laag, waardoor Power BI graph-data kan bevragen alsof ze relationeel is, met behoud van de snelheid en flexibiliteit van graph traversal.
Installeer de Neo4j BI Connector vanuit het Neo4j Download Center
De authenticatie gebeurt met de standaardgebruiker neo4j en het wachtwoord dat je kopieerde toen je voor het eerst een Neo4j graphDB aanmaakte
Bouw direct dashboards vanuit graph-views, zoals acteur-film-netwerken, influencer-rankings of gelijkenisclusters.
Deze setup omzeilt voorlopig de UI van de Fabric Graph Workload en maakt rechtstreeks verbinding met de onderliggende AuraDB-instance.
Ze is stabiel, production-ready en ideaal wanneer je interactieve Power BI-dashboards op graph-data wilt.
OVER DE AUTEUR
An De Lafonteyne
Managing Partner BE-Flanders
