AI BASED MOVIE RECOMMENDATION SYSTEM

A Project Report
submitted in partial fulfillment of the requirements for the award of the degree of

Master of Science in Computer Science

Banaras Hindu University

Submitted by
Bushra Ahmed

Under the guidance of

Supervisor Name

Department of Computer Science

Banaras Hindu University

2024–2025

i
 CONTENTS

1 INTRODUCTION 1
1.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Background . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.3 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.4 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.5 Objectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.6 Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.7 Methodology . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 LITERATURE REVIEW 4
2.1 Overview of Recommendation Systems . . . . . . . . . . . . . . . . . . . . . 4
2.2 NLP in Recommendation Systems . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Streamlit for Application Development . . . . . . . . . . . . . . . . . . . . . . 4
2.4 Summary of Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3 SYSTEM ANALYSIS 5
3.1 Existing System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.2 Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.3 Proposed System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.4 Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.5 Requirements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

4 SYSTEM IMPLEMENTATION 8
4.1 Architecture Diagram: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.2 UML Diagram: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.3 Entity-Relationship (ER) Diagram . . . . . . . . . . . . . . . . . . . . . . . . 10
4.4 Data Flow Diagram (DFD): . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4.5 Flowchart: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

5 Implementation 13
5.1 Technologies Used . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.2 Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

ii
 5.3 Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
5.4 Code Snippets: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
5.5 Database Design: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

6 Results 17
6.1 Screenshots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.2 Analysis: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6.3 Performance: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

7 ADVANTAGES AND LIMITATIONS 19

7.1 Advantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
7.2 Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

8 Future Work 20

9 Conclusiom 21

iii
 1 INTRODUCTION

Recommender systems have become an essential component of modern digital platforms. They
help users discover relevant content efficiently by analyzing preferences and patterns. The en-
tertainment industry, especially movie streaming platforms, heavily relies on recommendation
systems to enhance user engagement.
This project focuses on developing an AI-based movie recommendation system that sug-
gests movies based on content similarity using machine learning techniques.

1.1 OVERVIEW

This project develops an AI-driven movie recommendation system that tailors film suggestions
to the user’s mood and preferences . The application takes inputs such as the user’s current
emotional state (e.g., happy, sad, romantic, energetic) as well as favorite genres or actors, and
matches these with a curated movie dataset . By combining simple sentiment analysis (NLP-
based mood detection) and content f iltering, the system aims to provide personalized recom-
mendations that go beyond standard genre-based search. In this way, the app assists users in
navigating large OTT libraries, guiding them to movies that resonate with how they feel or what
they desire to watch at the moment

1.2 BACKGROUND

Recommendation systems are essential in digital platforms like Netflix and Amazon Prime,
assisting users to discover relevant content efficiently. These systems filter massive data to
provide personalized suggestions. Movie recommendation systems enhance user engagement
and satisfaction by offering tailored viewing options.

1.3 MOTIVATION

Traditional recommendation systems heavily rely on user history or collaborative filtering,

which cannot adapt to temporary emotional states. Human emotions significantly influence
entertainment preferences. This project aims to provide recommendations based on current
mood or favorite actors, making the system user-friendly and emotionally intelligent.

1
1.4 PROBLEM STATEMENT

Over-the-top streaming platforms host vast libraries of movies, often overwhelming users who
face hundreds or thousands of titles . This “content overload” leads to decision fatigue, where
users spend excessive time browsing without clear direction. Traditional recommendation sys-
tems on these platforms tend to rely on past viewing history or general popularity, neglecting
the user’s current context. As a result, users may miss out on relevant films that align with
their immediate mood or interests. The main problem addressed by this project is to reduce this
inefficiency by quickly filtering and presenting movies that match a user’s specified mood and
preferences, thereby saving time and enhancing the viewing.

1.5 OBJECTIVES

The primary objectives of this project are:

• Mood-Based Recommendations: Implement filtering logic to suggest movies aligned

with the user’s emotional state (e.g., Happy, Sad, Energetic)

• Preference Search: Enable users to refine results by specific genres or favorite actors,
ensuring suggestions match individual tastes

• User Interface Design: Create a simple, intuitive GUI (using Tkinter for desktop or
Flask for web) to allow easy input of mood and preferences and clear display of recom-
mendations .

• Visual Enhancement: Integrate external data (e.g., TMDB API) to fetch movie posters,
trailers, and additional details, improving the presentation of results.

• Efficiency:Optimize data handling (using Python and Pandas) to ensure fast response
times, even when processing large movie datasets.

1.6 SCOPE

The scope of this project is to develop a functional prototype that demonstrates the concept of
mood-aware movie recommendation. It focuses on personalization through immediate inputs
(mood, genre, actor) rather than long-term user profiling. The system uses a pre-collected
movie dataset (or TMDB API data) and implements rule-based filtering and sorting; it does
not employ complex machine learning models in the initial version. The project covers data
preprocessing, application logic, and interface development. By design, advanced features like
collaborative filtering, detailed user tracking, or real-time streaming integration are considered
beyond the current scope, to be explored in future work.

2
1.7 METHODOLOGY

The project follows a structured, step-by-step approach to development:

1. Data Acquisition: Gather a comprehensive movie dataset. This may involve download-
ing a CSV of movie information or using the TMDB API to collect details (titles, genres,
actors, etc.) .

2. Data Preprocessing and Tagging: Clean and organize the data. Tag each movie entry
with appropriate mood categories, genres, and lead actors to facilitate filtering .

3. Recommendation Engine Development: Implement the core logic in Python. Use Pan-
das to load the data and apply filters: matching user mood to movie mood tags, and
including any selected genre or actor preferences

4. User Interface Construction: : Build the front-end using Tkinter (for a desktop app)
or Flask (for a web app). The UI will allow users to enter their mood (via keyword or
dropdown) and other preferences, then view the resulting recommendations

5. Integration and Testing: Integrate the backend logic with the UI. Test the system by
simulating user inputs: verify that mood detection correctly identifies the entered emotion
and that the output list of movies accurately reflects the filters. Ensure results include key
details (title, genre, poster).

6. Iteration: Based on test feedback, iterate on the logic and interface to improve accuracy
and usability

3
 2 LITERATURE REVIEW

Recommender systems are a well-established area of research in computer science. Two pri-
mary techniques are collaborative filtering (CF) and content-based filtering (CBF) . CF predicts
user preferences by leveraging ratings or preferences from similar users, often requiring large
amounts of historical data. In contrast, CBF uses item attributes (e.g., genres, actors) to suggest
items similar to those a user liked in the past. In practice, many systems employ a hybrid of
both methods to improve accuracy

2.1 OVERVIEW OF RECOMMENDATION SYSTEMS

Recommendation systems can be broadly classified into:

1. Collaborative Filtering: Based on user-user or item-item similarities. Requires histori-

cal data.

2. Content-Based Filtering: Based on item attributes. Does not require user history.

3. Hybrid Systems: Combination of collaborative and content-based filtering for improved

accuracy.

2.2 NLP IN RECOMMENDATION SYSTEMS

Natural Language Processing is used to analyze textual inputs and detect user sentiment or
mood. It improves recommendation quality by aligning suggestions with the user’s emotional
state.

2.3 STREAMLIT FOR APPLICATION DEVELOPMENT

Streamlit provides a simple interface for deploying machine learning applications as interactive
web apps, enabling real-time user interaction

2.4 SUMMARY OF LITERATURE

Content-based filtering combined with NLP has been proven effective in providing personal-
ized, emotion-aware recommendations. This approach is efficient, interpretable, and feasible
for small to medium datasets.

4
 3 SYSTEM ANALYSIS

This chapter discusses the analysis of the existing and proposed systems.

3.1 EXISTING SYSTEM

Current movie platforms offer generic recommendation features, often based on popularity or
simple user profiles. Typically, users either browse by genre or rely on static “top picks” lists.
Very few mainstream systems allow filtering by a user’s emotional state. The usual process
involves manually scanning through categories or searching for known titles or actors. While
services may use collaborative filtering behind the scenes, this tends to suggest movies based
on past behavior rather than the user’s immediate mood or situation. As a result, users expend
effort in choice overload without receiving contextually targeted help

3.2 LIMITATIONS

The limitations of existing approaches include:-

-Information Overload: OTT platforms contain thousands of titles, which can overwhelm
users and waste [Link] often feel fatigued trying to find a suitable movie.
- Lack of Contextual Filtering: Current systems mostly use historical data or static filters
(genre, rating). They do not consider the user’s current emotional state or specific, momentary
preferences, leading to less relevant suggestions.
- Limited Personal Control: Users cannot easily specify what kind of movie they feel like
watching (beyond genre). There is no simple option to say “I am in a sad mood, show me
something uplifting.”
- Cold-Start Problem: New users or guest users (with no history) receive generic recom-
mendations that may not align with their tastes.
-Manual Effort: Without smart filtering, users must manually scroll through hundreds of
options, which is inefficient.

3.3 PROPOSED SYSTEM

The proposed system addresses these limitations by adding a mood-aware layer to movie rec-
ommendation. In this app, the user explicitly inputs their mood (e.g., Happy, Sad) and/or
specific preferences like a genre or favorite actor. The system then directly filters the dataset

5
to find movies tagged with that mood or matching those preferences. This ensures that re-
sults are immediately relevant to how the user feels, rather than relying on indirect signals. By
implementing content filtering with direct user criteria, the proposed app bridges the gap left
by existing systems. It enhances personalization by combining emotional cues with standard
filters, thereby improving relevance and user satisfaction.

3.4 FEATURES

Key features of the proposed system include:-

-Mood-Based Filtering: The system can recommend movies tailored to the user’s stated
mood ([Link] comedies for “Happy” or dramas for “Sad”)
- Preference Search: : Users can refine recommendations by selecting specific genres or
entering the names of favorite actors/actresses
- Intuitive User Interface: A clean GUI allows easy selection of mood and preferences.
For instance, buttons or dropdowns can capture emotional states, ensuring a simple user expe-
rience
- Visual Integration: The app optionally connects to external APIs (such as TMDB) to
fetch additional movie details like posters or trailers, enhancing presentation and helping users
decide
- Fast Filtering: Using Pandas and efficient data structures ensures that filtered results are
computed quickly, even with thousands of records

3.5 REQUIREMENTS

The project’s requirements are divided into software and hardware aspects:

• Hardware Requirements:A standard computer (desktop or laptop) capable of running

Python and a GUI framework (no specialized hardware is needed).

• Software Requirements:

• Python 3.x (for development and execution)

• Pandas library for efficient data handling and filtering.

• Tkinter (for desktop GUI) or Flask (for a web interface) to build the user interface.

• SQLite or CSV file for local storage of the movie dataset.

• Optional) Internet access and an API key for TMDB to retrieve movie posters and meta-
data.

6
• Functional Requirements:The system must accept user inputs (mood, genre, actor),
apply filters to the movie dataset, and display a sorted list of matching movies with key
details.

• Non -Functional Requirements:The interface should be user-friendly and responsive.

The recommendation process should execute quickly (minimal latency). The design
should allow easy updating of the dataset or addition of new moods/genres.

7
 4 SYSTEM IMPLEMENTATION

The system is implemented using Python and Streamlit.

4.1 ARCHITECTURE DIAGRAM:

The system uses a modular architecture (see Figure 1). The main components include:
- User Interface Module: Captures user inputs (mood, genre, actor) and displays recom-
mendations.
- Mood Detection Module: Interprets user-entered mood keywords using simple NLP
(e.g., mapping “happy” to a predefined mood tag).
- Filtering Engine: Processes the dataset to find movies that match the mood and prefer-
ence criteria.
-Database/Storage: Holds the movie dataset (in-memory or SQLite) with fields such as
title, genres, actors, mood tags, ratings.
-API Integration (Optional): Connects to TMDB to retrieve images and extra details for
display.

4.2 UML DIAGRAM:

Several UML diagrams would clarify the design. For example:

-Use-Case Diagram: Shows primary use cases like Select Mood, Choose Genre/Actor, and
View Recommendations, with the user as the actor.
-Class Diagram: Could outline classes such as Movie , UserPreferences , and For instance,
the Movie class might have attributes title , RecommenderEngine .genreList ,actorList , mood-
Tag , rating .
-Sequence Diagram: Illustrates the sequence when a user inputs mood and clicks ”Search”:
the UI sends data to the engine, which queries the data source and returns results.

8
 User
(Mood, Genre, Actor)

User Interface Module

(Streamlit / Web UI)

Mood Detection Module

- Keyword Mapping
- Simple NLP
(happy → joyful)

Filtering Engine
- Mood-based filter
- Genre filter
- Actor filter
- Rating threshold

Movie Dataset TMDB API

(CSV / SQLite) (Optional)
Title, Genre Posters, Cast
Recommendation Results
Mood Tags Ratings
- Movie List
- Posters & Details

Figure 4.1: System Architecture of Mood-Based Movie Recommendation System

User

Select Mood Choose Genre / Actor View Recommendations

Figure 4.2: Use Case Diagram of the Movie Recommendation System

9
 Movie

- title : String
- genre list : List
- actor list : List
- mood tag : String
- rating : Float

+ getDetails()

uses

RecommenderEngine

- movieDataset : List

+ filterByMood()
+ filterByGenre()
+ filterByActor()
+ recommendMovies()

reads

UserPreferences

- mood : String
- genre : String
- actor : String

+ setPreferences()

Figure 4.3: Class Diagram of the Movie Recommendation System

4.3 ENTITY-RELATIONSHIP (ER) DIAGRAM

An ER diagram would represent the database schema. A simplified design might include: -
Movies Table: Contains fields like MovieID (PK), Title, Genre, Actors, MoodTag, IMDBRat-
ing, etc.- (Optional) Genres Table: List of genre names if normalized.- (Optional) Actors Table:

10
 User UI RecommenderEngine
Enter Mood / Preferences
Click Search
sendRequest()

queryMovies()

returnResults()

returnResults()
Display Recommendations

Figure 4.4: Sequence Diagram of Movie Recommendation Process

List of actor names if normalized. In the simplest implementation, a single Movies table/CSV
holds all relevant attributes. The MoodTag field is assigned during preprocessing.

4.4 DATA FLOW DIAGRAM (DFD):

A DFD illustrates how data moves through the system. For example: - Level 0 DFD: Shows
user input entering the system and output (recommended movies) returning to the user.- Level 1
DFD: Breaks down processing into Capture Input, Process Input (mood detection), Filter Data,
and Display Output. This helps visualize data transitions: User provides mood/genre → system
queries the movie data → a filtered list is returned → UI displays results

4.5 FLOWCHART:

The following flowchart describes the recommendation logic:

1. Accept Input:The user selects a mood (e.g., “Happy”), and optionally a genre or actor.

2. Mood Detection: The system analyzes the input (keyword matching) to determine the
mood category.

3. Filtering:The movie dataset is filtered to include only those entries matching the de-
tected mood and any selected genres or actors.

4. Sorting:The filtered list is sorted, for instance by IMDB rating or relevance score.

5. Display: The top results are shown to the user, including movie titles, genres, and possi-
bly poster thumbnails.

This flow ensures a clear, step-by-step mapping from user action to the final recommendations
.

11
 User Input

Mood Detection

Filter Movies

Sort by IMDB Rating

Display Results

Figure 4.5: Flowchart of Mood-Based Movie Recommendation Process

12
 5 IMPLEMENTATION

5.1 TECHNOLOGIES USED

The project is implemented with the following tools and technologies:-

-Programming Language: Python 3.x – chosen for its simplicity and rich ecosystem of
data libraries.
-Data Handling: Pandas library is used for efficient data loading, cleaning, and filtering .
An optional SQLite database can store the movie data for quick queries.
-User Interface: Tkinter library is used for a desktop graphical interface, providing widgets
for user input and display. Alternatively, Flask could be used to create a web interface if desired
.
-External API: The TMDB (The Movie Database) API may be integrated to retrieve movie
posters, trailers,and additional details to enhance the UI .
- Others:Standard Python libraries (e.g., csv , processing is added) are utilized.

5.2 MODULES

The software is divided into modular components:-

-User Interface (UI) Module: Manages all GUI elements. It prompts the user to select a
mood, enter an actor name, and hit ‘Search’. It then displays the list of recommended movies
and their details.
-Mood Detection (NLP) Module: Takes the user’s mood input and determines the cor-
responding mood tag. For instance, it matches keywords like “happy”, “joyful”, or “excited”
to the “Happy” category. This can be implemented via a simple keyword dictionary or basic
sentiment analysis.
- Filtering Engine: Core logic that applies filters to the dataset. It queries the movie
dataset (in memory or database) using conditions: [Link] == userMood AND genre
== userGenre (if set) AND actorList contains userActor (if entered) . Matching entries are
collected and sorted by rating.
- Data Module: Loads and stores the movie dataset. It provides functions to query movies
by mood, genre,or actor. This could be a class that loads a CSV into a Pandas DataFrame on
startup.
- API Integration Module (Optional): Handles requests to the TMDB API. When given

13
a movie title or ID, it fetches the poster image URL and any extra info. This module enriches
the data for display in the UI.
Each module is designed to interact through well-defined interfaces. For example, the UI
calls the Filtering Engine with the user’s preferences, and the engine returns a ranked list of
movie objects

5.3 ALGORITHMS

The application uses straightforward algorithms:

• Mood Detection:A keyword-based approach is used. For example, if the user input
contains words like “happy”, “joy”, or “fun”, the mood is set to “Happy”; if “sad” or
“angry” are detected, it sets accordingly. This could be implemented by scanning the
input string for known mood words.

• Filtering Logic:The main algorithm iterates over the movie dataset and selects entries
matching the criteria. In Python/Pandas, this is done by Boolean indexing. For example:

Figure 5.1: Algorithm

This code loads a CSV of movies ([Link] ),filters rows by mood, genre, and actor,
then sorts the results by rating.

• Result Presentation: The sorted list is truncated to the top N movies (e.g., top 10) for
[Link] formatting (like fetching poster images) is done before rendering the
output.

5.4 CODE SNIPPETS:

Below is an illustrative Python snippet showing the filtering process:

This code demonstrates reading the dataset, applying filters based on mood, genre, and
actor, then sorting to get the highest-rated matches.

14
 Figure 5.2: Code Snippet

5.5 DATABASE DESIGN:

The movie dataset is organized in a table (or CSV) called Movies. A simplified schema is
as follows: The movie dataset is organized in a table (or CSV) called Movies. A simplified
schema is as follows:

• MovieID: Integer (Primary Key)

• Title: Text

• Genre: Text (comma-separated list of genres)

• Actors: Text (list of lead actors)

• MoodTag: Text (e.g., Happy, Sad, Romantic)

• IMDB Rating: Float (used for sorting and ranking)

• Year: Integer (optional)

• Description: Text (optional)

• Poster URL: Text (optional)

For example, a record might be: If a database were used, MoodTag could be a foreign key to
a separate Moods table (listing possible moods). For simplicity, this project primarily uses a

15
 Figure 5.3: DFD

single table or CSV file loaded into Pandas. The database (or CSV) is the primary data source
for the filtering algorithm.

16
 6 RESULTS

6.1 SCREENSHOTS

Figure 6.1: Main GUI where the user selects mood (e.g., via dropdown) and enters preferences.

Figure 6.2: Output screen showing recommended movie titles, genres, and poster images cor-
responding to the selected mood and filters.

Figure 6.3: Output screen showing recommended movie titles, genres, and poster images cor-
responding to the selected mood and filters.

These screenshots illustrate the front-end where inputs are given and recommendations
displayed. (Actual images would show the layout with buttons/fields and result list.)

17
6.2 ANALYSIS:

After implementation, the system was tested with various input combinations. For example,
when the user selects mood = “Happy” and genre = “Comedy”, the system returned a list of
uplifting comedic films sorted by rating. In trials, the results aligned well with expectations:
Happy moods returned comedies and family films, Sad moods returned dramas or tear-jerkers,
and specified actors (e.g., “Brad Pitt”) correctly filtered to movies starring them. This behavior
demonstrates that the filtering logic is functioning correctly. The relevance of recommendations
was evaluated informally by checking that top results indeed fit the criteria, suggesting the app
meets its goals of personalized suggestion. Feedback from initial users (peers) indicated that
the interface was easy to use and that mood-based results felt appropriate.

6.3 PERFORMANCE:

The performance of the application meets the requirements for responsiveness. On a typical
dataset of a few thousand movies, filtering and sorting operations complete in a fraction of
a second on a standard [Link] use of Pandas’ vectorized operations allows fast in-memory
computation. UI response (from clicking“Search” to seeing results) is nearly instantaneous in
our tests. No significant bottlenecks were found at this scale. For larger datasets or deployment,
future optimizations could include database indexing or asynchronous loading of poster images
to maintain quick performance. Overall, the system’s performance is sufficient for the current
scope of moderate data size and should scale adequately for classroom/project use.

18
 7 ADVANTAGES AND LIMITATIONS

7.1 ADVANTAGES

1. Mood-Aware Recommendations: Accurately suggests movies matching user’s current

emotion.

2. Actor-Based Search:Users can find movies featuring their favorite actors.

3. Content-Based Filtering Efficient for small to medium datasets without requiring user
history.

4. Interactive GUI:Streamlit UI provides visually appealing movie cards with posters, gen-
res, ratings, and summaries.

7.2 LIMITATIONS

1. Dataset Dependency:Limited to movies present in the dataset.

2. Keyword-Based Mood Detection: Simple mapping may not handle complex or am-
biguous inputs.

3. No Collaborative Filtering: Cannot recommend based on other users’ preferences.

4. Limited Personalization: Does not account for individual viewing history or prefer-
ences.

19
 8 FUTURE WORK

Possible enhancements and future developments include:

-Machine Learning Integration: Incorporate collaborative filtering or machine learning
models to learn from user behavior over time, enabling smarter, data-driven recommendations
.
-User Profiling:Implement user accounts and track viewing history or ratings. Over time,
the system could adapt to individual tastes and provide long-term personalized suggestions .
- Rating and Feedback: Allow users to rate or review suggested movies. This feedback
loop would refine the recommendation algorithm and improve accuracy .
-Contextual Awareness: Add context-sensitive features, such as recommending by time of
day (night vs morning), seasonal themes (holiday movies), or current trending topics for more
engaging suggestions .
- Mobile/Web Deployment: Develop a mobile app or full web application for wider ac-
cessibility, possibly with real-time updates and notifications.
- Enhanced Mood Detection: Use more advanced NLP or even sentiment analysis of user-
written text todetect nuanced emotions, improving the system’s understanding of user mood.
-Expanded Dataset: Integrate real-time data sources (other movie APIs) and maintain an up-
dated database for a broader range of movie choices.
These improvements would make the recommendation system more robust, personalized,
and aligned with real-world user behavior

20
 9 CONCLUSIOM

This project has successfully demonstrated a mood-aware movie recommendation system. By

focusing on the user’s current emotional state and preferences, the app effectively narrows
down a large set of films to those that resonate with how the user feels. The implementation in
Python (with Pandas and a GUI) proved capable of delivering fast, personalized suggestions.
Key objectives were met: the system includes mood-based filtering, allows genre and actor
preferences, and presents results in a clear interface. The solution addresses the problem of
content overload on OTT platforms by automating the search process. Initial testing showed
that recommended movies indeed matched user inputs (e.g., suggesting comedies for a “Happy”
mood), indicating improved relevance compared to generic search. In summary, the project
achieves its goal of enhancing user experience through intelligent filtering. It stands as a useful
prototype illustrating the potential of incorporating user mood into recommendation logic

21
REFERENCE

22
 BIBLIOGRAPHY

[1] Kaggle Movie Metadata Dataset. Available at: [Link]

[2] Scikit-learn Documentation. Available at: [Link]

[3] TMDB API Documentation. Available at: [Link]

[4] Streamlit Official Documentation. Available at: [Link]

[5] Ricci, F., Rokach, L., & Shapira, B. (2015). Recommender Systems Handbook. Springer.

[6] Aggarwal, C. C. (2016). Recommender Systems: The Textbook. Springer.

23