Behind the Scenes: Building a Connected Movie Universe in Fabric

To make the Neo4j Graph Workload tangible, we explored it with a movie dataset stored in OneLake — tables for Movies, Persons (actors, directors), Users, and Roles (links between people and movies).

Traditional table queries answer facts easily: “Which movies did Tom Hanks play in?” But the moment you ask “Who tends to act together?” or “Which movies should we recommend?” — relational joins become complex, inefficient, and hard to reason about. This is exactly where the graph approach shines.

Step 1: Start in Fabric

In your Fabric workspace, click New → Neo4j Graph Workload. Choose a name, confirm the region (must match your Fabric capacity region), and Fabric will connect to Neo4j AuraDB and create a 14-day free trial tied to your tenant — setup takes less than a minute.

Step 2: Load Movie Data to Lakehouse

We created dummy movie data in CSVs (downloadable at GitHub) and loaded them into Delta tables in a Lakehouse.

Step 3: Turn It into a Graph

Create a new Neo4j Graph Dataset item, select your Lakehouse and all its tables. The GenAI-assisted modeling automatically transforms tabular data into a graph structure.

At this stage the graph model is generated but data hasn’t loaded yet — you can still refine the model. You can also extend it by adding new nodes (e.g. Country) and relationships (FILMED-IN, LIVED-IN) before loading.

To load data into the graph DB, click Transform to Graph.

Analyze and Enrich the Graph

Exploring Your Graph Visually

The Explore tool (powered by Neo4j Bloom) lets you interact with your graph visually inside Fabric — search for patterns, expand relationships, and filter nodes to uncover hidden connections — no queries needed.

Querying Your Graph with Cypher

From the Query button, write and run Cypher queries directly against your graph. Results that include graph structures display as an interactive network; scalar values show as a table.

Example 1: Aggregated Query (Table View)

Count how many movies each actor appeared in:

MATCH (p:Person)-[:ACTS_IN]->(m:Movie)
RETURN p.name AS actor, count(m) AS movies
ORDER BY movies DESC
LIMIT 50;

Example 2: Relationship Query (Graph View)

Find actors who co-starred with Sam Monroe and visualize the collaboration network:

MATCH (a:Person {name: "Sam Monroe"})-[r1:ACTS_IN]->(m:Movie)<-[r2:ACTS_IN]-(co:Person)
RETURN a, r1, m, r2, co
LIMIT 50;

Using Graph Data Science (GDS)

With movie data in Neo4j, GDS lets you go beyond exploration to measure influence, find communities, and surface similarity. Examples:

• Communities (Louvain/LPA): discover actor ensembles that frequently co-star
• Influence (PageRank/Betweenness): find bridge actors who connect clusters
• Similarity (Node Similarity/Jaccard): suggest new collaborations
• Paths (k-hop queries): trace collaboration chains between actors

Materialize a Co-Acting Network

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;

Project the Graph and Run Louvain Community Detection

CALL gds.graph.drop('coacting', false);

CALL gds.graph.project(
  'coacting', 'Person',
  { CO_ACTED_WITH: { orientation: 'UNDIRECTED', properties: 'weight' } }
);

CALL gds.louvain.write('coacting', {
  relationshipWeightProperty: 'weight',
  writeProperty: 'communityId'
})
YIELD communityCount, modularity;

Now every (:Person) has a communityId — use it to color nodes in Explorer or filter in Cypher/Power BI.

Operationalize It: Friend-Based Movie Recommendations

After running graph algorithms, the natural next step is operationalizing insights. Using the social graph (User)-[:FOLLOWS]->(User)-[:RATES]->(Movie), you can compute which movies a user’s trusted friends rate highly — then write results back to Fabric Lakehouse for broader consumption.

The Fabric notebook below computes Top 5 friend-based movie recommendations per user and writes them to a Delta table:

%pip install --quiet neo4j~=5.28.0 pandas~=2.2.2

from neo4j import GraphDatabase
import pandas as pd

AURA_URI      = "neo4j+s://<YOURINSTANCE>.databases.neo4j.io"
AURA_USER     = "neo4j"
AURA_PASSWORD = "<YOURPASSWORD>"

cypher = """
MATCH (u:User)
CALL (u) {
  WITH u
  MATCH (u)-[:FOLLOWS]->(f:User)-[r:RATES]->(m:Movie)
  WHERE NOT (u)-[:RATES]->(m)
  WITH m, avg(coalesce(r.rating, 0.0)) AS score, count(*) AS votes
  ORDER BY score DESC, votes DESC
  LIMIT $top
  RETURN m.title AS movie, score, votes
}
RETURN u.name AS user, movie, score, votes
ORDER BY user ASC, score DESC
"""

with GraphDatabase.driver(AURA_URI, auth=(AURA_USER, AURA_PASSWORD)) as driver:
    with driver.session() as session:
        recs = pd.DataFrame(session.run(cypher, {"top": 5}).data())

# Write to Delta table in Lakehouse
sdf = spark.createDataFrame(recs)
sdf.write.format("delta").mode("overwrite").save("Tables/neo4j_movies_recs_friends")

Visualizing Graph Insights in Power BI

Power BI can connect straight to Neo4j AuraDB using the Neo4j BI Connector (ODBC/JDBC). This translates Cypher query results into a virtual SQL layer — allowing Power BI to query graph data as if it were relational.

Authentication uses the default user neo4j and the password copied when the graph DB was created.

This setup bypasses the Fabric Graph Workload UI for now, connecting directly to the AuraDB instance. It’s stable, production-ready, and ideal for interactive Power BI dashboards on graph data.