Movie Recommender System Project
A Streamlit-based movie recommendation application that suggests movies based on similarity metrics and content-based filtering.
Inspiration
I wanted to challenge myself and do something different—something that would apply real-world data science concepts. The Movie Recommender System allowed me to work with actual datasets and build a meaningful application that people could use, rather than just another simple game.
What It Does
The application uses content-based filtering to recommend movies based on a user's selection. Users can choose any movie, and the system analyzes its features (genres, cast, ratings, keywords, and more) to find and display similar movies. Each recommendation includes the movie poster, IMDb rating, genre information, and release year to help users discover their next favorite film.
Project Structure
├── app.py # Main Streamlit application
├── main.py # Core application logic
├── main.ipynb # Jupyter notebook with full workflow
├── movies.pkl # Pre-trained movie data (pickled)
├── tmdb_5000_credits.csv # TMDB credits dataset
├── tmdb_5000_movies.csv # TMDB movies dataset
└── requirements.txt # Python dependencies
Technology Stack
- Streamlit - Web application framework
- Python - Core programming language
- Pandas - Data manipulation and analysis
- Scikit-learn - Machine learning algorithms for similarity metrics
- Jupyter Notebook - Development and experimentation
- The Movie Database (TMDB) - Data source
How It Works
The recommendation system uses a content-based filtering approach:
- Data Loading - Loads movie data from TMDB datasets
- Feature Engineering - Extracts relevant features (genres, credits, ratings, etc.)
- Similarity Calculation - Computes similarity between movies using cosine similarity
- Recommendation Generation - Finds the most similar movies to a user's selected movie
How We Built It
The project was developed using Python and Streamlit as the primary framework. We started by exploring the TMDB 5000 movie dataset using Jupyter Notebook to understand the data structure and relationships. The core algorithm uses cosine similarity to compare movies based on their feature vectors. We preprocessed and engineered features from both the movies and credits datasets, then built the Streamlit interface to make it accessible and interactive. The final application was deployed on Streamlit Cloud for live access.
Challenges We Ran Into
This was my first major project, and I encountered numerous learning opportunities along the way. The biggest challenges included:
- Git & Version Control - Understanding how to properly use Git, manage branches, and push commits was initially confusing
- Deployment - Getting the application deployed on Streamlit Cloud required troubleshooting dependencies and environment configurations
- Data Processing - This was my first time applying data processing concepts in a real-world project, which involved learning how to clean, transform, and engineer features from raw CSV data
- Module Integration - Learning new libraries like Pandas, Scikit-learn, and Streamlit and figuring out how to use them effectively together
- Feature Engineering - Understanding which movie attributes to use and how to vectorize them for similarity calculations
Accomplishments We're Proud Of
- Successfully built a fully functional recommendation system that actually works
- Deployed a live web application that others can access and use
- Applied machine learning concepts learned in class to a practical problem
- Created a user-friendly interface that makes recommendations feel intuitive
- Managed to implement a complex data science project despite being a beginner
What We Learned
• Gained practical experience in integrating and preprocessing multiple datasets by merging the movies and credits CSV files into a unified structure. • Extracted relevant fields (title, genres, cast, crew, overview) and constructed a combined “tagline” feature for analysis. • Learned how to clean and stem text data using NLTK to improve consistency. • Transformed text into numerical vectors with CountVectorizer and applied cosine similarity to generate meaningful recommendations. • Worked with external APIs such as OMDb and IMDb to fetch posters and metadata reliably. • Designed fallback mechanisms for missing posters and handled oversized images to ensure a consistent user experience. • Built an interactive interface with Streamlit, learning how to design responsive layouts and present recommendations in a visually engaging format. • Explored model persistence with pickle to optimize performance and reduce runtime delays. • Successfully deployed the project publicly on Streamlit Cloud, making it accessible to anyone with a browser. • Strengthened skills in Python programming, machine learning concepts, API integration, and web application deployment, while enhancing the ability to design workflows that balance technical accuracy with user-friendly presentation.
What's Next for Movie Recommender System
- Collaborative Filtering - Implement user-based recommendations based on viewing history and ratings
- User Accounts - Add authentication to save user preferences and recommendation history
- Advanced Models - Experiment with hybrid recommendation systems combining content and collaborative filtering
- Performance Optimization - Optimize the similarity calculations for faster recommendations
- Enhanced UI - Redesign the interface with more interactive features and filtering options
- Real-time Updates - Integrate with TMDB API for updated movie data
- Mobile App - Develop a mobile version of the recommendation system
Live Application
Try the app here: https://movie-recommender-project120.streamlit.app/
