DEV Community: Kshitij Gawankar

🎬 Building a Movie Recommendation System with Neo4j + Node.js

Kshitij Gawankar — Mon, 18 Aug 2025 06:26:33 +0000

👋 Introduction

Ever wondered how Netflix or Marvel fans get “because you watched this…” suggestions? In this blog, I’ll walk you through building a real-world Movie Recommendation System using Neo4j (graph database) and Node.js.

Unlike traditional SQL databases, Neo4j shines when you want to store relationships (like “User → Likes → Movie”). That’s why it’s perfect for recommendations.

We’ll build a mini Netflix-style engine that knows which movies you like and suggests others you might enjoy.
🛠️ Tech Stack

Neo4j → Graph database to store movies, users, and relationships.

Node.js → Server-side runtime to interact with Neo4j.

neo4j-driver → Official driver to connect Node.js with Neo4j.

Github Repository:-https://github.com/Kshitij-0007/neo4j
📂 Project Setup

1. Initialize Project

mkdir neo4j-movie-recommendation
cd neo4j-movie-recommendation
npm init -y
npm install neo4j-driver dotenv

Add .env File

NEO4J_URI=bolt://localhost:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=yourpassword

package.json Update

{
"name": "movie-recommendation",
"version": "1.0.0",
"description": "A movie recommendation system using Neo4j and Node.js",
"main": "index.js",
"type": "module",
"scripts": {
"start": "node index.js"
},
"dependencies": {
"neo4j-driver": "^5.15.0",
"dotenv": "^17.2.1"
}
}

🎥 Sample Data (Marvel + Netflix Movies)

We’ll create some users and movies, then connect them with LIKES relationships.

index.js

import neo4j from "neo4j-driver";
import dotenv from "dotenv";

dotenv.config();

const driver = neo4j.driver(
process.env.NEO4J_URI,
neo4j.auth.basic(process.env.NEO4J_USER, process.env.NEO4J_PASSWORD)
);

const session = driver.session();

async function main() {
try {
// Clear existing DB
await session.run("MATCH (n) DETACH DELETE n");

// Create Movies
await session.run(`
  CREATE (m1:Movie {title: "Avengers: Endgame", genre: "Action"})
  CREATE (m2:Movie {title: "Doctor Strange", genre: "Fantasy"})
  CREATE (m3:Movie {title: "The Witcher", genre: "Fantasy"})
  CREATE (m4:Movie {title: "Money Heist", genre: "Thriller"})
  CREATE (m5:Movie {title: "Stranger Things", genre: "Sci-Fi"})
  CREATE (m6:Movie {title: "Loki", genre: "Action"})
`);

// Create Users
await session.run(`
  CREATE (u1:User {name: "Arjun"})
  CREATE (u2:User {name: "Meera"})
  CREATE (u3:User {name: "Karan"})
`);

// Create Relationships
await session.run(`
  MATCH (u1:User {name: "Arjun"}), (m1:Movie {title: "Avengers: Endgame"})
  CREATE (u1)-[:LIKES]->(m1);

  MATCH (u1:User {name: "Arjun"}), (m2:Movie {title: "Doctor Strange"})
  CREATE (u1)-[:LIKES]->(m2);

  MATCH (u2:User {name: "Meera"}), (m3:Movie {title: "The Witcher"})
  CREATE (u2)-[:LIKES]->(m3);

  MATCH (u2:User {name: "Meera"}), (m4:Movie {title: "Money Heist"})
  CREATE (u2)-[:LIKES]->(m4);

  MATCH (u3:User {name: "Karan"}), (m5:Movie {title: "Stranger Things"})
  CREATE (u3)-[:LIKES]->(m5);

  MATCH (u3:User {name: "Karan"}), (m6:Movie {title: "Loki"})
  CREATE (u3)-[:LIKES]->(m6);
`);

console.log("✅ Database seeded with movies and users!");

// Recommendation Query
const result = await session.run(`
  MATCH (u:User {name: "Arjun"})-[:LIKES]->(m:Movie)<-[:LIKES]-(other:User)-[:LIKES]->(rec:Movie)
  WHERE u <> other AND NOT (u)-[:LIKES]->(rec)
  RETURN DISTINCT rec.title AS recommendation
`);

console.log("🎯 Recommendations for Arjun:");
result.records.forEach(record => {
  console.log("👉 " + record.get("recommendation"));
});

} catch (error) {
console.error("Error:", error);
} finally {
await session.close();
await driver.close();
}
}

main();

🚀 Run the Project
npm start

You’ll see something like:

✅ Database seeded with movies and users!
🎯 Recommendations for Arjun:
👉 The Witcher
👉 Money Heist
👉 Stranger Things
👉 Loki

🧩 How It Works

Users are connected to movies via LIKES relationships.

The Cypher query finds other users with similar tastes.

It returns movies they liked that Arjun hasn’t watched yet.

This mimics a collaborative filtering recommendation system.

📊 Visualizing the Graph

Open the Neo4j Browser (http://localhost:7474/) and run:

MATCH (n) RETURN n

You’ll see users and movies connected in a graph — like your own mini Netflix brain 🧠.

🎁 Next Steps

Add more genres and ratings.

Build a simple frontend to display recommendations.

Expand dataset with real movie datasets (IMDb, TMDb).

🙌 Conclusion

And there you have it — a Movie Recommendation System in less than 100 lines of code using Neo4j + Node.js.

Graph databases make relationships first-class citizens, which makes recommendation engines super easy and natural.

If you enjoyed this, drop a ❤️ on Dev.to, connect with me, and check out the GitHub repo.

🧠 I Rebuilt Tetris with an AI Brain Using Amazon Q CLI – Neon Tetris

Kshitij Gawankar — Thu, 19 Jun 2025 13:00:29 +0000

Ever thought Tetris needed a glow-up?

I did — and thanks to Amazon Q Developer CLI, I didn’t just build a Tetris clone... I built Neon Tetris: an AI-enhanced, retro-themed version with brainpower, beauty, and a background track that hits you with nostalgia and chill.

This is my submission for the #BuildGamesChallenge using #AmazonQDevCLI – a global event where developers reimagine classic games through the power of conversational AI.

🧩 Challenge Breakdown

🎯 Why I Chose Tetris

Tetris is the OG puzzle game — timeless, addictive, and beautifully simple. But I wanted to bring it into 2025 with a twist: AI + glowing visuals + dynamic gameplay. Tetris gave me the perfect base to explore real-time logic, visual feedback, and adaptive difficulty all in one project.

🛠️ Prompting Techniques I Discovered

Instead of micro-managing each file or feature, I went high-level with prompts like:

"Build a modular Tetris game with AI helper logic that uses heuristics to suggest optimal moves. Include ghost piece, theme switching, and dynamic difficulty based on player performance."

This let Q CLI do the heavy lifting. I followed up with focused prompts like:

"Add a performance tracker that monitors score and adjusts speed."
"Create a theme switcher with Neon, Dark, and Retro themes."
"Write a helper class that calculates best piece placement using heuristics."

These small conversational tweaks saved HOURS of setup and rewrites.

🤖 How AI Handled Classic Game Dev Challenges

Q CLI impressed me with:

Clean module separation for game logic, AI, rendering, and input
Automatically generated code that worked out of the box
Clear comments and docstrings for most generated methods

I rarely had to fight with the code — I was just refining it and adding polish.

🔁 Automation That Saved Me Time

Project Structure Generation: The full game skeleton (files + folders) was built in seconds
Heuristic AI Logic: It created a scoring system using classic Tetris metrics like holes, bumpiness, and height
Control Mapping: Auto-added standard controls + pause/restart/quit states
Theme Manager: I just said “switchable themes” and it wrote the class, handled key inputs, and applied different styles. Insane.

🎥 Gameplay Demo

Check out the full video here! 🎮👇

📺 Watch on YouTube

🎮 Why Tetris?

Tetris is the ultimate retro puzzle game. It’s simple, fast, and satisfying. But what if it evolved with AI?

With Neon Tetris, I added:

🤖 AI that suggests your next best move
🎭 Switchable themes (Neon, Dark, Retro)
📈 Dynamic difficulty based on player skill
👻 Ghost piece to preview hard drops
🎵 A peaceful Tetris piano + lullaby remix soundtrack

Built using Amazon Q CLI, this was about more than just coding — it was about prompting.

💬 Prompting the Game into Existence

Here’s an example of what I told Q CLI:

“Create a modular Tetris game with an AI Helper. The AI should recommend the best position for the current piece based on heuristics like aggregate height, complete lines, holes, and bumpiness. Add a ghost piece, dynamic difficulty, theme switching, and modular file structure.”

Q CLI broke this down into a full project with:

📁 main.py – Game loop & inputs
📁 game.py, board.py, tetromino.py – Core Tetris mechanics
📁 ai_helper.py – Heuristic-based AI recommendation engine
📁 theme_manager.py – Multiple themes with switch key
📁 performance_tracker.py – Player analytics for dynamic speed
📁 renderer.py – Handles visuals, ghost piece, UI

🧠 The AI Helper Logic

The AI evaluates every possible move using the following heuristics:

📏 Aggregate Height
🕳️ Holes
📊 Bumpiness
✅ Completed Lines

It then recommends the best move by showing a ghost piece, helping players improve their strategy.

🎛️ Controls

⬅️➡️⬆️⬇️ Arrow Keys: Move & rotate
🔳 Space: Hard drop
🅰️ A: Toggle AI helper
🔤 T: Change theme
🔍 G: Toggle ghost piece
⏸️ P: Pause
🔄 R: Restart (on game over)
❌ Q: Quit (on game over)

🧵 Final Thoughts
This challenge showed me that AI is no longer just a helper — it’s a real dev partner.
Amazon Q CLI let me build something playable, clean, and smart — just by talking to it.

Big thanks to the AWS Build Games Challenge team for making this possible.
And if you're a dev who loves building games but hates boilerplate, Q CLI is your new best friend.

🎮 Game on.

#BuildGamesChallenge
#AmazonQDevCLI #GameDev
#Python #PyGame #AI
#RetroGaming #MadeWithAI

📦 Try It Yourself

📁 GitHub Repository:

👉 https://github.com/Kshitij-0007/Neon_Tetris

🧰 Requirements:

Python 3.6+
Pygame 2.5.2+

⚡ Installation:


bash
git clone https://github.com/Kshitij-0007/Neon_Tetris
cd Neon_Tetris
pip install -r requirements.txt
python main.py

🥷 I Built a Procedural Ninja Stealth Game in Python – "Openstate" (with Amazon Q CLI)

Kshitij Gawankar — Tue, 17 Jun 2025 09:49:56 +0000

Ever wanted to sneak through a maze as a shadowy ninja, dodging guards, grabbing scrolls, and escaping undetected?
That’s exactly what I built with Openstate — a 2D stealth platformer game using Python, Pygame, and scaffolding powered by Amazon Q CLI.

Let me take you through how I made it, what makes it tick, and how you can play it or even build your own.

🎮 What is Openstate?
Openstate is a procedurally generated stealth game where you:

Sneak past patrolling guards with line-of-sight vision

Collect hidden scrolls across a maze

Use shadows and bushes to hide

Escape through the exit — all without being caught

Each level gets harder, and every run is unique thanks to procedural generation.

🎥 Gameplay Demo
👉 Watch the full gameplay of Openstate here: https://youtu.be/vvg_KIyrTkg

🧠 Key Features
🎯 Cone-of-vision AI: Guards detect you based on realistic field of vision

🔁 Procedurally generated levels: New maze every time

🌌 Dynamic guard speed: Increasing challenge each level

📜 Scroll collection for stars

🥷 Crouch, hide, and sneak to survive

🌟 3-star rating system: Based on scrolls collected, exit reached, and stealth success

🔁 Game over + restart system if caught

🛠️ How It Was Built
📁 Modular Architecture
player.py: Movement, jumping, crouching, hiding

guard.py: AI, patrol logic, detection

level.py: Handles maze, scrolls, exit, guards

maze_generator.py: DFS-based maze generation

ui.py: Timer, star count, detection alerts

💻 Powered by Amazon Q CLI
Amazon Q CLI helped scaffold the basic architecture for this project — making it easier to organize the code and scale features over time.
It was part of the "Build Games with Amazon Q CLI" challenge.

🧪 Challenges Faced
Tuning AI to be “dumb but fair” (nobody likes psychic guards)

Ensuring maze generation always leads to an exit

Getting animations and UI overlays working properly in Pygame

🚀 Try the Game Yourself
💻 Clone the Repo:
bash
Copy
Edit
git clone https://github.com/Kshitij-0007/openstate
cd openstate
pip install -r requirements.txt
python main.py
🔗 GitHub Repo: https://github.com/Kshitij-0007/openstate

🧠 Lessons Learned
Procedural generation adds replayability — but also debugging nightmares 😅

Simple AI systems can feel very smart with just a cone of vision and patrols

Amazon Q CLI can boost productivity and structure — especially for solo devs

🛣️ What’s Next for Openstate?
🔮 Smoke bombs to distract guards

🧠 Smarter guard AI variations

🧱 Level editor for custom mazes

💾 Save/load progress

🛍️ In-game power-ups like invisibility or speed boost

🙌 Final Thoughts
This was built as part of the Amazon Q CLI Game Jam, and I’m super proud of how it turned out. If you're from Amazon and reading this — this ninja humbly accepts T-shirt tributes 👕✨

Thanks for reading, and go give it a try!
Got feedback? Fork it? Want to collab? Let’s connect!

🔧 Built With:
Python 3.9

Pygame

Amazon Q CLI

Canva (video editing)

🕶️ Peace, scrolls, and silent footsteps.

python #pygame #gamedev #amazonqcli #opensource #devchallenge #stealthgame #indiedev #proceduralgeneration

Let me know if you'd like a thumbnail image or a post for LinkedIn
too. Let's get this ninja everywhere. 🥷💻💥