Building a recommendation engine with Neo4j: A step-by-step tutorial

Are you ready to take your recommendation engine to the next level? Are you ready to harness the power of Neo4j to build a cutting-edge recommendation engine that blows your competitors out of the water?

If the answer is yes, then you've come to the right place! In this tutorial, we'll take you through the process of building a recommendation engine with Neo4j step by step.

So, why Neo4j, you may ask? Well, Neo4j is a graph database that excels at handling complex relationships between data points. And what is a recommendation engine but a complex web of relationships between data points?

With Neo4j, we can easily model and traverse these relationships, allowing us to build robust and accurate recommendations with ease.

So, without further ado, let's get started!

Step 1: Setting up the environment

The first thing we need to do is set up our environment. We'll assume you already have Neo4j installed, so we won't go into that here.

Next, we'll need to install some Python packages. We'll be using Flask for our web framework and py2neo to interface with Neo4j.

To install these packages, simply run the following commands in your terminal:

pip install Flask
pip install py2neo

Once you have these packages installed, we can move on to the next step.

Step 2: Creating our data model

Now that we have our environment set up, we need to create our data model.

For the purpose of this tutorial, we'll be building a movie recommendation engine. Our data model will consist of two primary nodes: User and Movie. We'll also have a RATED relationship connecting the two, which will include a rating property.

To create our data model, we'll need to create a schema in Neo4j. You can do this using the Neo4j browser or any client of your choosing.

Here's the Cypher code to create our schema:

CREATE (:User {id: "1", name: "Alice"})
CREATE (:User {id: "2", name: "Bob"})
CREATE (:User {id: "3", name: "Charlie"})

CREATE (:Movie {id: "1", title: "The Shawshank Redemption", year: "1994"})
CREATE (:Movie {id: "2", title: "The Godfather", year: "1972"})
CREATE (:Movie {id: "3", title: "The Godfather: Part II", year: "1974"})
CREATE (:Movie {id: "4", title: "The Dark Knight", year: "2008"})
CREATE (:Movie {id: "5", title: "12 Angry Men", year: "1957"})
CREATE (:Movie {id: "6", title: "Schindler's List", year: "1993"})
CREATE (:Movie {id: "7", title: "The Lord of the Rings: The Return of the King", year: "2003"})
CREATE (:Movie {id: "8", title: "Pulp Fiction", year: "1994"})
CREATE (:Movie {id: "9", title: "The Lord of the Rings: The Fellowship of the Ring", year: "2001"})

MATCH (u:User {id: "1"}), (m:Movie {id: "1"})
CREATE (u)-[:RATED {rating: 10}]->(m)

MATCH (u:User {id: "1"}), (m:Movie {id: "2"})
CREATE (u)-[:RATED {rating: 7}]->(m)

MATCH (u:User {id: "1"}), (m:Movie {id: "3"})
CREATE (u)-[:RATED {rating: 5}]->(m)

MATCH (u:User {id: "2"}), (m:Movie {id: "1"})
CREATE (u)-[:RATED {rating: 9}]->(m)

MATCH (u:User {id: "2"}), (m:Movie {id: "2"})
CREATE (u)-[:RATED {rating: 8}]->(m)

MATCH (u:User {id: "2"}), (m:Movie {id: "3"})
CREATE (u)-[:RATED {rating: 7}]->(m)

MATCH (u:User {id: "2"}), (m:Movie {id: "4"})
CREATE (u)-[:RATED {rating: 10}]->(m)

MATCH (u:User {id: "3"}), (m:Movie {id: "1"})
CREATE (u)-[:RATED {rating: 8}]->(m)

MATCH (u:User {id: "3"}), (m:Movie {id: "5"})
CREATE (u)-[:RATED {rating: 9}]->(m)

MATCH (u:User {id: "3"}), (m:Movie {id: "7"})
CREATE (u)-[:RATED {rating: 10}]->(m)

MATCH (u:User {id: "3"}), (m:Movie {id: "9"})
CREATE (u)-[:RATED {rating: 8}]->(m)

This will create our User and Movie nodes with some example data and the RATED relationships between them. Feel free to modify this data to fit your needs.

Step 3: Building our Flask app

Now that we have our data model set up, we can start building our Flask app.

Create a new file called and enter the following code:

from flask import Flask, jsonify
from py2neo import Graph

app = Flask(__name__)
graph = Graph()

# Get recommendations for a user
def get_recommendations(id):
    query = '''
        MATCH (:User {id: $id})-[:RATED]->(m:Movie)<-[:RATED]-(:User)-[:RATED]->(rec:Movie)
        WHERE NOT (:User {id: $id})-[:RATED]->(rec)
        WITH rec, COUNT(*) AS score
        RETURN rec.title AS title, rec.year AS year, score
        ORDER BY score DESC
        LIMIT 10
    results =, id=id)
    return jsonify([{"title": row["title"], "year": row["year"], "score": row["score"]} for row in results])

if __name__ == '__main__':

This app will define a GET endpoint at /api/user/<id>/recommendations that takes a user ID as a parameter and returns the top 10 movie recommendations for that user.

We'll use the py2neo package to interface with our Neo4j database. Make sure you configure your database URL and credentials before running the app.

Step 4: Testing the app

With our app built, it's time to test it out!

Start your Flask app by running python in your terminal. If everything is set up correctly, you should see the following output:

 * Running on (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!

Now, open up a web browser and navigate to http://localhost:5000/api/user/1/recommendations. This should return a JSON object with the top 10 movie recommendations for user 1:

        "title": "The Godfather: Part II",
        "year": "1974",
        "score": 2
        "title": "The Dark Knight",
        "year": "2008",
        "score": 1
        "title": "12 Angry Men",
        "year": "1957",
        "score": 1

Congratulations, you've just built a recommendation engine with Neo4j!


In this tutorial, we went through the process of building a recommendation engine with Neo4j step by step. We started by setting up our environment, creating our data model, building our Flask app, and finally testing it out.

We hope this tutorial has given you a good introduction to building recommendation engines with Neo4j. Of course, this is just the tip of the iceberg – there's so much more you can do with Neo4j!

If you're interested in learning more, be sure to check out the Neo4j documentation and join the Neo4j community. Happy coding!

Editor Recommended Sites

AI and Tech News
Best Online AI Courses
Classic Writing Analysis
Tears of the Kingdom Roleplay
Graph Database Shacl: Graphdb rules and constraints for data quality assurance
Data Integration - Record linkage and entity resolution & Realtime session merging: Connect all your datasources across databases, streaming, and realtime sources
Cloud Serverless: All about cloud serverless and best serverless practice
Prompt Catalog: Catalog of prompts for specific use cases. For chatGPT, bard / palm, llama alpaca models
Switch Tears of the Kingdom fan page: Fan page for the sequal to breath of the wild 2