Forget ChatGPT — Claude 3.7 Sonnet Is the AI You Need to Try!

Develop a streamlit app by using Claude’s new model

March 19, 2025
Data Science ChatGPT AI All Articles
Forget ChatGPT — Claude 3.7 Sonnet Is the AI You Need to Try!

AI has changed our words daily, but you should not worry about each piece of news. We are here for you, and now Claude has published something worthwhile.

 

Claude has published an amazing model, but is it really good enough? In this article, we have developed a streamlit app that will help you sort movies based on your selections like this.

SS of IMDB 2024 Movie Explorer

 

So say goodbye to spending hours selecting a movie you like, and you’ll do this with AI. Let’s start!

Claude 3.7 Sonnet

 

Claude’s new model offered better coding capabilities, which we can test, especially in data analysis.

 

SS of New Model

 

So, let’s select a Kaggle Dataset to test it!

 

IMDB 2024 Dataset

 

Reference

 

I enjoy watching movies, but these days, finding a good one can take longer than actually watching it! So, while analyzing this dataset, maybe you and I will discover a great movie and improve our day!

 

Prompt Perfector

 

 

https://learnaiwithme.net/assistants/

Now let’s select prompt perfector and send our dataset details to it like this;

Here is my dataset details :[copy from Kaggle]
Can you suggest me a prompt to find best movies according my taste in 2024?

Good, here is the output.

 

SS of the Prompt Perfector

Based on my dataset, recommend the best movies released in 2024 that match 
my taste. My preferences include [your favorite genres], movies featuring 
[your favorite actors], and those with a high IMDb rating (Vote_Average above 
[your preferred rating threshold]). Prioritize movies with a strong storyline, 
high production value (Budget_USD above [your budget threshold]), and 
significant audience engagement (Vote_Count above [your preferred threshold]).
 Exclude movies with low ratings or poor reviews. Provide the Movie_Name, 
Genres, Cast, Vote_Average, and a brief Overview for each recommendation.

Here, fill these;

  • your favorite genres] → Example: Action, Sci-Fi, Thriller
  • [your preferred rating threshold] → Example: 7.5 (for IMDb rating)
  • [your budget threshold] → Example: $50M (for high-budget movies)
  • [your preferred vote count threshold] → Example: 10,000 votes (for popular movies)
  • [your preferred runtime range] → Example: At least 90 minutes
  • [your preferred release country] → Example: USA, UK, South Korea

 

Good, we shaped our prompt. Here is an example of usage;

Find the best action and sci-fi movies released in 2024 with an IMDb 
rating above 7.5.
Prioritize movies with a budget above $50M and at least 10,000 votes. 
Provide the title, genres, cast, rating, and a short description.

 

Let’s load the dataset to the Claude 3.7 Sonnet with our prompt!

Claudes Data Analyzing Feature

After loading the data and using the prompt above, here is the result.

SS of ChatGPT

Built a Streamlit App with Claude

 

I am not into animations yet, but I watched the trailer of the Fallout and I like it very much, it looks like the movie I am going to watch today is now defined!

However, we built a system that allows us to select the genres, ratings, or even cast of this dataset(2024) and find the movies.

Let’s use this as a prompt and send it to the class!

But, we build a system, where we can select the genres, rating or even cast of this dataset(2024) and find the movies? Maybe streamlit?

 

It sends us a long code, check please:

import streamlit as st
import pandas as pd
import ast
import plotly.express as px
from collections import Counter
import numpy as np

# Set page configuration
st.set_page_config(
    page_title="IMDB 2024 Movie Explorer",
    page_icon="🎬",
    layout="wide"
)

# Function to load and process data
@st.cache_data
def load_data():
    # Load the CSV file
    df = pd.read_csv('cleaned_imdb_2024.csv')
    
    # Convert string representations of lists to actual lists
    for col in ['Genres', 'Cast', 'Original_Language', 'Production_Company']:
        df[col] = df[col].apply(lambda x: ast.literal_eval(x) if isinstance(x, str) and x.startswith('[') else x)
    
    # Clean up numeric columns
    # Convert Vote_Average to float if it's not already
    if df['Vote_Average'].dtype != 'float64':
        df['Vote_Average'] = pd.to_numeric(df['Vote_Average'], errors='coerce')
    
    # Extract numeric values from Budget_USD
    df['Budget_USD_Clean'] = df['Budget_USD'].str.replace('$', '').str.replace('M', '000000')
    df['Budget_USD_Clean'] = pd.to_numeric(df['Budget_USD_Clean'].str.replace(',', ''), errors='coerce')
    
    # Clean Vote_Count (convert K to thousands)
    def clean_vote_count(vote_count):
        if isinstance(vote_count, str):
            if 'K' in vote_count:
                return float(vote_count.replace('K', '')) * 1000
            else:
                return float(vote_count.replace(',', ''))
        return vote_count
    
    df['Vote_Count_Clean'] = df['Vote_Count'].apply(clean_vote_count)
    
    # Convert Release_Date to datetime
    df['Release_Date'] = pd.to_datetime(df['Release_Date'], errors='coerce')
    
    return df

# Load the data
df = load_data()

# App header
st.title("🎬 IMDB 2024 Movie Explorer")
st.markdown("Explore movies released in 2024 with interactive filtering capabilities.")

# Sidebar filters
st.sidebar.header("Filters")

# Extract unique genres from all movies
all_genres = []
for genres in df['Genres']:
    if isinstance(genres, list):
        all_genres.extend(genres)
unique_genres = sorted(list(set(all_genres)))

# Allow multiple genre selection
selected_genres = st.sidebar.multiselect("Select Genres", unique_genres)

# Rating filter
min_rating, max_rating = st.sidebar.slider(
    "IMDb Rating Range",
    min_value=float(df['Vote_Average'].min()),
    max_value=float(df['Vote_Average'].max()),
    value=(7.0, float(df['Vote_Average'].max())),
    step=0.1
)

# Vote count filter
min_votes = st.sidebar.number_input(
    "Minimum Vote Count",
    min_value=0,
    max_value=int(df['Vote_Count_Clean'].max()),
    value=1000
)

# Budget filter (if available)
if 'Budget_USD_Clean' in df.columns:
    has_budget_data = st.sidebar.checkbox("Only include movies with budget data")

# Cast filter - allow search by cast member
all_cast = []
for cast_list in df['Cast']:
    if isinstance(cast_list, list):
        all_cast.extend(cast_list)
cast_counter = Counter(all_cast)
top_cast = [actor for actor, count in cast_counter.most_common(100)]

cast_search = st.sidebar.text_input("Search for Cast Member")
if cast_search:
    matching_cast = [actor for actor in top_cast if cast_search.lower() in actor.lower()]
    if matching_cast:
        selected_cast = st.sidebar.selectbox("Select Cast Member", matching_cast)
    else:
        selected_cast = None
        st.sidebar.write("No matching cast members found.")
else:
    selected_cast = None

# Apply filters
filtered_df = df.copy()

# Filter by genres
if selected_genres:
    filtered_df = filtered_df[filtered_df['Genres'].apply(
        lambda x: isinstance(x, list) and any(genre in selected_genres for genre in x)
    )]

# Filter by rating
filtered_df = filtered_df[(filtered_df['Vote_Average'] >= min_rating) & 
                         (filtered_df['Vote_Average'] <= max_rating)]

# Filter by vote count
filtered_df = filtered_df[filtered_df['Vote_Count_Clean'] >= min_votes]

# Filter by budget if selected
if 'Budget_USD_Clean' in df.columns and has_budget_data:
    filtered_df = filtered_df[filtered_df['Budget_USD_Clean'] > 0]

# Filter by cast
if selected_cast:
    filtered_df = filtered_df[filtered_df['Cast'].apply(
        lambda x: isinstance(x, list) and selected_cast in x
    )]

# Main content area with tabs
tab1, tab2, tab3 = st.tabs(["Movies", "Analytics", "About"])

with tab1:
    # Display number of results
    st.subheader(f"Found {len(filtered_df)} movies matching your criteria")
    
    # Sort options
    sort_options = ["Vote Average (High to Low)", "Vote Count (High to Low)", 
                   "Release Date (Newest First)", "Title (A-Z)"]
    sort_choice = st.selectbox("Sort by:", sort_options)
    
    if sort_choice == "Vote Average (High to Low)":
        filtered_df = filtered_df.sort_values(by='Vote_Average', ascending=False)
    elif sort_choice == "Vote Count (High to Low)":
        filtered_df = filtered_df.sort_values(by='Vote_Count_Clean', ascending=False)
    elif sort_choice == "Release Date (Newest First)":
        filtered_df = filtered_df.sort_values(by='Release_Date', ascending=False)
    else:
        filtered_df = filtered_df.sort_values(by='Movie_Name')
    
    # Display movies as cards
    if not filtered_df.empty:
        # Create three columns for the cards
        cols = st.columns(3)
        
        for i, (_, movie) in enumerate(filtered_df.iterrows()):
            col = cols[i % 3]
            
            with col:
                st.markdown("---")
                st.markdown(f"### {movie['Movie_Name']}")
                
                # Genre badges
                if isinstance(movie['Genres'], list):
                    genres_str = ' '.join([f"<span style='background-color:#e0e0e0; padding:2px 6px; border-radius:10px; margin-right:5px; font-size:0.8em;'>{g}</span>" for g in movie['Genres']])
                    st.markdown(genres_str, unsafe_allow_html=True)
                
                # Rating and votes
                st.markdown(f"⭐ **{movie['Vote_Average']:.1f}** ({int(movie['Vote_Count_Clean']):,} votes)")
                
                # Release date
                if pd.notna(movie['Release_Date']):
                    st.markdown(f"📅 **Release Date:** {movie['Release_Date'].strftime('%B %d, %Y')}")
                
                # Budget (if available)
                if 'Budget_USD_Clean' in df.columns and pd.notna(movie['Budget_USD_Clean']) and movie['Budget_USD_Clean'] > 0:
                    st.markdown(f"💰 **Budget:** ${movie['Budget_USD_Clean']:,.0f}")
                
                # Cast (first 3 cast members)
                if isinstance(movie['Cast'], list) and len(movie['Cast']) > 0:
                    cast_display = ', '.join(movie['Cast'][:3])
                    if len(movie['Cast']) > 3:
                        cast_display += f" and {len(movie['Cast']) - 3} more"
                    st.markdown(f"🎭 **Cast:** {cast_display}")
                
                # Overview
                if pd.notna(movie['Overview']):
                    st.markdown(f"**Overview:** {movie['Overview'][:200]}..." if len(movie['Overview']) > 200 else f"**Overview:** {movie['Overview']}")
    else:
        st.info("No movies match your current filter criteria. Try adjusting the filters.")

with tab2:
    st.subheader("Analytics")
    
    # Genre distribution
    if not filtered_df.empty:
        st.markdown("### Genre Distribution")
        
        # Count genre occurrences across filtered movies
        genre_counts = Counter()
        for genres in filtered_df['Genres']:
            if isinstance(genres, list):
                genre_counts.update(genres)
        
        # Convert to dataframe for plotting
        genre_df = pd.DataFrame({
            'Genre': list(genre_counts.keys()),
            'Count': list(genre_counts.values())
        }).sort_values(by='Count', ascending=False)
        
        # Plot horizontal bar chart
        fig = px.bar(
            genre_df, 
            y='Genre', 
            x='Count', 
            orientation='h',
            title='Movie Count by Genre',
            color='Count',
            color_continuous_scale='Viridis'
        )
        st.plotly_chart(fig, use_container_width=True)
        
        # Rating distribution
        st.markdown("### Rating Distribution")
        fig = px.histogram(
            filtered_df, 
            x='Vote_Average',
            nbins=20,
            title='Distribution of Movie Ratings',
            color_discrete_sequence=['#3366cc']
        )
        fig.update_layout(bargap=0.1)
        st.plotly_chart(fig, use_container_width=True)
        
        # Release date distribution by month
        if 'Release_Date' in filtered_df.columns:
            valid_dates = filtered_df[pd.notna(filtered_df['Release_Date'])]
            if not valid_dates.empty:
                valid_dates['Month'] = valid_dates['Release_Date'].dt.strftime('%B')
                month_order = ['January', 'February', 'March', 'April', 'May', 'June', 
                              'July', 'August', 'September', 'October', 'November', 'December']
                
                # Count movies per month
                month_counts = valid_dates['Month'].value_counts().reindex(month_order).fillna(0)
                month_df = pd.DataFrame({
                    'Month': month_counts.index,
                    'Count': month_counts.values
                })
                
                st.markdown("### Release Distribution by Month")
                fig = px.bar(
                    month_df,
                    x='Month',
                    y='Count',
                    title='Movie Releases by Month',
                    color='Count',
                    color_continuous_scale='Viridis'
                )
                st.plotly_chart(fig, use_container_width=True)
        
        # Top 10 highest rated
        st.markdown("### Top 10 Highest Rated Movies")
        top_rated = filtered_df.sort_values(by='Vote_Average', ascending=False).head(10)
        fig = px.bar(
            top_rated,
            y='Movie_Name',
            x='Vote_Average',
            orientation='h',
            title='Top 10 Highest Rated Movies',
            color='Vote_Count_Clean',
            color_continuous_scale='Viridis',
            labels={'Vote_Count_Clean': 'Vote Count'}
        )
        st.plotly_chart(fig, use_container_width=True)
        
        # Budget vs. Rating (if budget data is available)
        if 'Budget_USD_Clean' in filtered_df.columns:
            budget_df = filtered_df[pd.notna(filtered_df['Budget_USD_Clean']) & (filtered_df['Budget_USD_Clean'] > 0)]
            if not budget_df.empty:
                st.markdown("### Budget vs. Rating")
                fig = px.scatter(
                    budget_df,
                    x='Budget_USD_Clean',
                    y='Vote_Average',
                    size='Vote_Count_Clean',
                    color='Vote_Average',
                    hover_name='Movie_Name',
                    log_x=True,
                    title='Movie Budget vs. Rating',
                    labels={
                        'Budget_USD_Clean': 'Budget (USD, log scale)',
                        'Vote_Average': 'IMDb Rating',
                        'Vote_Count_Clean': 'Vote Count'
                    }
                )
                st.plotly_chart(fig, use_container_width=True)
    else:
        st.info("No data to analyze based on current filters. Try adjusting the filters.")

with tab3:
    st.markdown("""
    ## About This App
    
    This IMDB 2024 Movie Explorer app allows you to browse and analyze movies released in 2024.
    
    ### Features
    - **Filter by genre, rating, and cast members**
    - **Sort results by rating, popularity, or release date**
    - **View detailed movie information**
    - **Explore data analytics and visualizations**
    
    ### Data Source
    The data is from IMDb's 2024 movie database, containing information on movie titles, genres, cast, ratings, budget, and more.
    
    ### How to Use
    1. Use the sidebar filters to narrow down your movie search
    2. Switch between tabs to view the list of movies or analytics
    3. Sort the results based on your preferences
    
    ### Technologies Used
    This app was built with:
    - Streamlit
    - Pandas
    - Plotly
    
    ### Note
    This is a demonstration application using sample data. For the most current movie information, please visit the official IMDb website.
    """)

# Footer
st.markdown("---")
st.markdown("Built with ❤️ using Streamlit")

Let’s save it to the Python file.

Running The Streamlit App

 

Now, let’s go to where you saved your Python file inside your terminal. If you are using a Mac, here is the code.

cd [path to your python file]

Now, let’s run this as a streamlit app.

streamlit run movies.py # movies.py = the name of your app

Here is the result.

Streamlit app

 

Is not that amazing? Let’s select action.

 

Streamlit app

 

Now you’ve built an app in a matter of minutes!

Final Thoughts

 

In this one, we created a streamlet app using Claude 3.7. I think it's really good, and they improved its coding ability.

If you like what you saw, you can subscribe to us from substack. If you really like what you saw, you can visit our platform, LearnAIWithME, which includes Assistants, AI Projects, and Editors Pick, where you can summarize AI news by just clicking!

See you there! Here are free resources;

Here are the free resources.

Here is the ChatGPT cheat sheet.

Here is the Prompt Techniques cheat sheet.

Here is my NumPy cheat sheet.

Here is the source code of the “How to be a Billionaire” data project.

Here is the source code of the “Classification Task with 6 Different Algorithms using Python” data project.

Here is the source code of the “Decision Tree in Energy Efficiency Analysis” data project.

Here is the source code of the “DataDrivenInvestor 2022 Articles Analysis” data project.

 

“Machine learning is the last invention that humanity will ever need to make.” Nick Bostrom