Build a Movie Recommendation App with Python, OpenAI, and Twilio SendGrid

Time to read: 9 minutes

October 28, 2024

Written by

Contributor

Reviewed by

Twilion

In an era of information overload and decision fatigue, tools that simplify our choices while catering to our emotional needs are invaluable. Sometimes, all it takes is the right movie to turn your day around. Feeling down, anxious, or just stuck in a funk? Movies can tap into your emotions and lift you out of those moods, giving you a sense of escape or even a fresh perspective. Whether you're looking for something to brighten your spirits, ease stress, or channel your excitement, the Mood-Based Cinematic Curator is here to help. It’s more than just a movie suggestion tool. It’s a way to sync your emotions with the perfect film, offering a remedy for whatever mood you're in.

This innovative app doesn't just recommend movies. It curates a personalized cinematic experience tailored to your current emotional state. By leveraging the power of natural language processing, machine learning, and AI, our app understands the nuances of human emotion and translates them into spot-on movie suggestions.

In this tutorial, you’ll learn how to build this Mood-Based Cinematic Curator. You'll use Flask for backend, harnessing the power of OpenAI's GPT-4 for intelligent movie recommendations. Tapping into The Movie Database (TMDb) API for rich movie details, and implementing Twilio SendGrid to keep users engaged with personalized email notifications.

Prerequisites

Before you start building, you will need the following:

Python 3.7 or later installed.
A Twilio account. If you don’t have an account, you can sign up for a free account.
An OpenAI account and API key creation. You can sign up for a new account here.
A TMDb API key. You can sign up to create an account.
Basic understanding of Python.

Set up the Project

To create a new directory for your project and navigate to it. Open your terminal and run the commands below:

mkdir mood-based-cinematic-curator
cd mood-based-cinematic-curator

mkdir: This creates a new directory called mood-based-cinematic-curator.

cd: This changes your working directory to the newly created folder, so all further commands are run within this project directory.

Next, you create a virtual environment for the project and activate it. A virtual environment helps isolate the project's dependencies so they don’t interfere with other Python projects on your machine. Run the command below:

python -m venv moodBooster
   moodBooster\Scripts\activate

python -m venv moodBooster: This creates a virtual environment named moodBooster.

moodBooster\Scripts\activate: This activates the virtual environment on Windows.

Install the Required Libraries

With the virtual environment activated, run the command below to install the necessary Python libraries using pip:

pip install flask openai python-dotenv requests transformers sendgrid torch

flask: A lightweight web framework for Python.

openai: The library to interact with OpenAI's API.

python-dotenv: To load environment variables from a .env file.

requests: For making HTTP requests.

transformers: A library by Hugging Face for natural language processing (NLP) tasks, useful for working with OpenAI models.

sendgrid: A library to send emails via SendGrid.

torch: The transformers library uses torch as its backend. Without torch installed, you'd get an import error when trying to use the emotion classification model

Create a `.env` file

The .env file stores your API keys and sensitive configuration data in an easily manageable and secure way. Create this file in your project’s root directory and add the following keys:

OPENAI_API_KEY=your_openai_api_key
   TMDB_API_KEY=your_tmdb_api_key
   SENDGRID_API_KEY=your_sendgrid_api_key
   SENDGRID_FROM_EMAIL=your_sendgrid_email

Replace the placeholder values with the actual API keys, which will be loaded in your application. For you to be able to acquire the services needed from the third party applications.

This setup prepares the foundation of the project. Which allows you to build an application that can integrate with OpenAI, TMDB, and SendGrid APIs for AI-based film recommendations and notifications.

Now proceed to acquire the required API keys that will allow the communication between the application and the third party applications.

Obtain the API Keys

Configure your OpenAI Account

To set up your OpenAI account and obtain an API key, visit the OpenAI website and log in to your OpenAI dashboard. Follow the provided instructions to generate an API key tailored to your account. Securely copy and add it to the .env file. It will be used for authentication of requests to the OpenAI API from your Flask application. It enables it to leverage OpenAI's natural language processing capabilities effectively.

Click on Create new secret key. You are prompted to enter the name of the API key and then click again on Create new secret key to generate the API key. Copy the API key and add it to your .env file under the OPENAI_API_KEY.

With the above in place, you are now able to analyze and recommend films.

Configure your TMDb Account

After obtaining the OpenAI credential, you will need to get your API key from TMDB to make the interaction. Create an account on the TMDB signup page, and then verify your account by clicking the blue button labeled Activate My Account in the verification email you receive. Log in to your account and then request an API key by clicking the link under Request an API Key on this page.

Register as a Developer and fill out the API request form completely with the respective details, and then click submit. Once you’ve done so, you should land on a page that contains your API Key, as shown in the screenshot below. Copy the API key and paste it in your .env file under the TMDB_API_KEY value.

With the above in place, you are now able to query for movies.

Configure your SendGrid Account

Secure your SendGrid credentials needed to work with your application. This allows you to authenticate your requests and send emails through following the process below.

To begin, access your SendGrid dashboard and navigate to Settings > Sender Authentication. Look for and click on the Verify a Single Sender button to start the verification process. You'll need to fill out the sender details form with your From Name (your name or company name), From Email Address (the email you'll send from), Company Name and Address, and Website. After completing the form, click Create and check your email inbox. You'll receive a verification link that you'll need to click to complete this process.

Once sender verification is complete, return to your SendGrid dashboard. Navigate to Settings > API Keys in the left sidebar. Click on the Create API Key button, then choose Full Access as shown in the screenshot below.

Next, give your API key a name. Feel free to give it a name of your choice, then click Create & View for the API generation to take effect.

After creation, SendGrid will display your API key. This is the only time you'll see the full key, so make sure to copy it immediately and add it to your .env file under the SENDGRID_API_KEY value.

With the setup done right, proceed to the coding section, which binds everything together.

Create the Flask Application

Start by building the basic structure of your Flask application. Create a folder in the root directory and name it templates. Inside the templates directory, create a file and name it mood_check.html. This will contain the code of your user interface. Next, create a file named app.py for the main function in the root directory and update it with the code below.

from flask import Flask, request, render_template, jsonify
import openai
import os
from transformers import pipeline
import torch
from dotenv import load_dotenv 
import requests
from sendgrid import SendGridAPIClient
from sendgrid.helpers.mail import Mail
app = Flask(__name__)
load_dotenv()
openai.api_key = os.getenv('OPENAI_API_KEY')
tmdb_api_key = os.getenv('TMDB_API_KEY')
SENDGRID_API_KEY = os.getenv('SENDGRID_API_KEY')
senders_email= os.getenv('SENDGRID_FROM_EMAIL')
classifier = pipeline("text-classification", model="bhadresh-savani/bert-base-uncased-emotion")

The code imports the necessary libraries and initializes the Flask app. It then uses load_dotenv() to load the environment variables from the .env file. The OpenAI API key and other keys are retrieved using os.getenv(). Next, the emotion classifier model is initialized using Hugging Face’s transformers library. This model will classify the user's mood based on their input.

Fetch Movie Details from TMDB

To retrieve movie details such as the title, poster, and link from TMDB add a function that queries the TMDB API. Copy this code to your app.py file.

def get_movie_details(title):
    search_url = f"https://api.themoviedb.org/3/search/movie?api_key={tmdb_api_key}&query={title}"
    response = requests.get(search_url)
    if response.status_code == 200:
        results = response.json()['results']
        if results:
            movie = results[0]
            return {
                'title': movie['title'],
                'poster': f"https://image.tmdb.org/t/p/w500{movie['poster_path']}" if movie['poster_path'] else None,
                'link': f"https://www.themoviedb.org/movie/{movie['id']}"
            }
    return None

The get_movie_details function constructs a URL to query the TMDB API for movies that match the movie titles suggested by OpenAI's GPT model. If the response is successful, it extracts the movie's details, including the title, poster image URL, and a link to the TMDB page. If no results are found, it returns None.

Write the Flask Route to Display the Main Page

This route renders the HTML template mood_check.html, which is the main page where users can express how they are feeling, add their email, and get a recommendation. Copy the code below and add it to the app.py file.

@app.route('/')
def index():
    return render_template('mood_check.html')

The form on this page collects user input and submits it to the /analyze route for processing.

Analyze the User’s Mood and Provide Recommendations

In this step, you create the analyze route which is the core route in this application. Copy the code below and add it to the app.py file.

@app.route('/analyze', methods=['POST'])
def analyze():
    try:
        user_input = request.form['user_input']
        user_email = request.form.get('user_email')
        app.logger.info(f"User input received: {user_input}")
        classification = classifier(user_input)[0]
        emotion = classification['label']
        app.logger.info(f"Detected emotion: {emotion}")
        openai_client = openai.OpenAI(api_key=openai.api_key)
        system_message = """You are a movie recommendation assistant. Based on the user's detected emotion, suggest 3 appropriate movies. For each emotion:
        - Joy/Love: Suggest uplifting or romantic movies
        - Sadness: Recommend heartwarming or inspirational films
        - Anger: Propose calming or comedy movies
        - Surprise: Suggest thrilling or mind-bending films
        - Fear: Recommend light-hearted or family-friendly movies
        Provide only the titles of the 3 recommended movies, separated by commas."""
        response = openai_client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": system_message},
                {"role": "user", "content": f"The user's detected emotion is: {emotion}"}
            ]
        )
        movie_titles = response.choices[0].message.content.split(', ')
        movies = []
        for title in movie_titles:
            movie_details = get_movie_details(title)
            if movie_details:
                movies.append(movie_details)
            app.logger.info(f"Movie details for {title}: {movie_details}")
        result = {
            'emotion': emotion,
            'movies': movies
        }
        if user_email:
            email_sent = send_recommendation_email(user_email, emotion, movies)
            result['email_sent'] = email_sent
        app.logger.info(f"Returning result: {result}")
        return jsonify(result)
    except Exception as e:
        app.logger.error(f"An error occurred: {e}")
        return jsonify({'error': str(e)}), 500

This route handles the POST request sent when a user submits their mood description and email. It's responsible for processing the user's input, determining their mood, generating movie recommendations, and sending an email.

First, the app extracts the user's input and email from the form data. Then, it uses a pre-trained emotion classification model to determine the user's emotional state based on their input.

With the emotion classified, the application taps into the power of OpenAI's GPT-4o model. You provide the AI with a carefully crafted system message that essentially says, "You're a movie recommendation assistant. Based on this emotion, suggest three appropriate movies." You then feed it the detected emotion and await its response.

Once we receive the movie recommendations from OpenAI, you don't stop there. For each recommended movie, you reach out to The Movie Database (TMDB) API to fetch additional details like the movie poster and a link to more information. This enriches our recommendations, providing users with more context and visual appeal.

With the user provided email address, you take an extra step to enhance their experience. You use your Twilio SendGrid integration to email them containing their detected mood and movie recommendations. This allows users to revisit their personalized recommendations later, even after closing their browser.

This analyze function serves as the heart of our Cinematic Curator. It orchestrates a complex dance between emotion analysis, natural language processing, and multiple external APIs, all to deliver a uniquely personalized movie recommendation experience.

Send Email with Twilio SendGrid

Using OpenAI’s GPT-4, you’ll generate film recommendations based on the user’s mood. This function sends a prompt to GPT-4 to request mood-specific movie titles. Copy the code below and add it to the app.py file.

def send_recommendation_email(to_email, emotion, movies):
    message = Mail(
        from_email='senders_email',
        to_emails=to_email,
        subject='Your Movie Recommendations Based on Your Mood',
        html_content=f'''
        <h2>Your detected mood: {emotion}</h2>
        <h3>Here are your movie recommendations:</h3>
        <ul>
        {''.join([f"<li><a href='{movie['link']}'>{movie['title']}</a></li>" for movie in movies])}
        </ul>
        ''')
    try:
        sg = SendGridAPIClient(SENDGRID_API_KEY)
        response = sg.send(message)
        print(f"Email sent. Status code: {response.status_code}")
        return True
    except Exception as e:
        print(f"Error sending email: {str(e)}")
        return False
if __name__ == '__main__':
    app.run(debug=True)

This function constructs an email using the SendGrid Mail helper. The from_email is set to the sender's email address, which is retrieved from the . env file. The body of the email contains the detected emotion and a list of film recommendations. The SendGridAPIClient(SENDGRID_API_KEY) sends the email, and the function prints the status of the email send operation. If an error occurs, it prints the error and returns False.

Next, you’ll see how the frontend works in association with the backend.

Build the Frontend of the application

Create a new file named mood_check.html in a templates folder and add the following code content:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Mood-based Movie Recommender</title>
    <script src="https://cdn.tailwindcss.com"></script>
</head>
<body class="bg-gradient-to-r from-blue-500 to-purple-600 min-h-screen flex items-center justify-center p-4">
    <div class="bg-white p-8 rounded-lg shadow-md w-full max-w-2xl">
        <h1 class="text-3xl font-bold mb-4 text-center text-gray-800">How are you feeling?</h1>
        <p class="mb-4 text-center text-gray-600">Get Movie Recommendations</p>
        <form id="moodForm" class="mt-4">
            <textarea id="userInput" name="user_input" rows="4" class="w-full p-2 border rounded-md" placeholder="Describe how you're feeling..."></textarea>
            <input type="email" id="userEmail" name="user_email" class="w-full mt-2 p-2 border rounded-md" placeholder="Your email (optional)">
            <button type="submit" class="mt-4 bg-blue-500 text-white px-4 py-2 rounded-md hover:bg-blue-600">Get Recommendations</button>
        </form>
        <div id="loading" class="mt-4 text-center hidden">
            Analyzing your mood and finding perfect movies for you...
        </div>
        <div id="error" class="mt-4 text-center hidden text-red-500">
            An error occurred. Please try again.
        </div>
        <div id="result" class="mt-4 hidden">
            <h2 class="text-xl font-semibold mb-2 text-gray-800">Your Mood: <span id="detectedMood"></span></h2>
            <h2 class="text-xl font-semibold mb-2 text-gray-800">Recommended Movies:</h2>
            <div id="movieRecommendations" class="grid grid-cols-1 md:grid-cols-3 gap-4"></div>
        </div>
    </div>
    <script>
        document.getElementById('moodForm').addEventListener('submit', async (e) => {
            e.preventDefault();
            const userInput = document.getElementById('userInput').value;
            const userEmail = document.getElementById('userEmail').value;
            document.getElementById('loading').classList.remove('hidden');
            document.getElementById('result').classList.add('hidden');
            document.getElementById('error').classList.add('hidden');
            try {
                const formData = new FormData();
                formData.append('user_input', userInput);
                formData.append('user_email', userEmail);
                const response = await fetch('/analyze', {
                    method: 'POST',
                    body: formData
                });
                if (!response.ok) {
                    throw new Error('Network response was not ok');
                }
                const data = await response.json();
                document.getElementById('detectedMood').textContent = data.emotion;
                const recommendationsDiv = document.getElementById('movieRecommendations');
                recommendationsDiv.innerHTML = '';
                data.movies.forEach(movie => {
                    const movieDiv = document.createElement('div');
                    movieDiv.className = 'bg-white p-4 rounded-lg shadow';
                    movieDiv.innerHTML = `
                        <img src="${movie.poster || '/path/to/placeholder-image.jpg'}" alt="${movie.title}" class="w-full h-48 object-cover rounded-md mb-2">
                        <h3 class="font-semibold text-lg mb-1">${movie.title}</h3>
                        <a href="${movie.link}" target="_blank" class="text-blue-500 hover:underline">More Info</a>
                    `;
                    recommendationsDiv.appendChild(movieDiv);
                });
                document.getElementById('result').classList.remove('hidden');
                if (data.email_sent) {
                    alert('An email with your recommendations has been sent!');
                }
            } catch (error) {
                console.error('Error:', error);
                document.getElementById('error').classList.remove('hidden');
            } finally {
                document.getElementById('loading').classList.add('hidden');
            }
        });
    </script>
</body>
</html>

The HTML structure includes a form for users to input their mood and provide an email address.

It uses Tailwind CSS classes to style the page, ensuring a visually appealing and responsive layout. The template includes elements to show loading status and potential error messages. JavaScript is used to handle the form submission, fetch data from the backend, and update the user interface with the movie recommendations with results asynchronously or any errors that may occur.

Test the Application

Find the full source code in this GitHub repository.

Navigate to the project directory in your terminal. Run the Flask application by executing the command:

python app.py

This will start the web server locally. Open a web browser and navigate to the URL provided by Flask, typically http://localhost:5000. You should see a homepage as shown in the screenshot below.

On the webpage, express yourself in the provided text area and provide your email too. Then click the Get Recommendations button to submit. As show in the screenshot below.

Now with that in place, check your email. It should contain the links suggested, as shown in the screenshot below.

What's next for OpenAI and SendGrid projects?

Congratulations! By following this tutorial, you've built an AI-powered movie recommendation system that understands users' emotions and delivers personalized suggestions right to their inbox. Throughout this journey, you've learned how to analyze sentiment using AI, generate contextual movie recommendations with OpenAI's GPT, and send beautiful, personalized emails using Twilio SendGrid.

This project not only showcases the potential of integrating advanced AI models with modern web applications, but also emphasizes the importance of emotional well-being through tailored recommendations.

If you are looking for ways to further enhance your application, check out these articles for inspiration:

Jacob Muganda is a full-stack developer and Machine Learning enthusiast. He enjoys leveraging AI solutions in software applications.

Related Resources

Twilio Docs

From APIs to SDKs to sample apps

API reference documentation, SDKs, helper libraries, quickstarts, and tutorials for your language and platform.

Resource Center

The latest ebooks, industry reports, and webinars

Learn from customer engagement experts to improve your own communication.

Ahoy

Twilio's developer community hub

Best practices, code samples, and inspiration to build communications and digital engagement experiences.

Build a Movie Recommendation App with Python, OpenAI, and Twilio SendGrid

Related Posts

Related Resources

From APIs to SDKs to sample apps

The latest ebooks, industry reports, and webinars

Twilio's developer community hub