Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,167 +1,852 @@
-🔍 Searching for similar content to: Dick Johnson Is Dead (ID: s1)
-
-📋 Table structure for mp7bnn9tzhojh7k:
-
-Columns:
-
-[
-0:"Id"
-1:"CreatedAt"
-2:"UpdatedAt"
-3:"title"
-4:"show_id"
-5:"similar_items"
-]
-Sample row:
-
-{
-"Id":1
-"CreatedAt":"2025-06-02 09:34:10+00:00"
-"UpdatedAt":NULL
-"title":"Dick Johnson Is Dead"
-"show_id":"s1"
-"similar_items":"[{"title": "Triple Threat", "show_id": "s3718", "similarity": 0.7407444080262803}, {"title": "The Death and Life of Marsha P. Johnson", "show_id": "s5234", "similarity": 0.7343378197080184}, {"title": "Toxic Beauty", "show_id": "s1715", "similarity": 0.7338750075490208}, {"title": "The Possession of Michael King", "show_id": "s8177", "similarity": 0.731497980641655}, {"title": "Suspiria", "show_id": "s4051", "similarity": 0.7215465108599116}, {"title": "The Sheik", "show_id": "s3726", "similarity": 0.7167594371495939}, {"title": "Operation Avalanche", "show_id": "s8106", "similarity": 0.7060483371270012}, {"title": "Trying Grace", "show_id": "s7595", "similarity": 0.7044626409776164}, {"title": "Shanghai Disney Resort Grand Opening Gala", "show_id": "s295", "similarity": 0.7035801295960805}, {"title": "The Legend of Swee' Pea", "show_id": "s565", "similarity": 0.6992762418494328}, {"title": "The Z Virus", "show_id": "s8732", "similarity": 0.6908215252006857}, {"title": "Extremis", "show_id": "s5798", "similarity": 0.6867877195283146}, {"title": "Journey to Royal: A WWII Rescue Mission", "show_id": "s4807", "similarity": 0.6830348539927185}, {"title": "Narbachi Wadi", "show_id": "s5879", "similarity": 0.6824890235942042}, {"title": "Daredevil DIRECTOR'S CUT", "show_id": "s8325", "similarity": 0.6810832334129707}, {"title": "Aurinko In Adagio: A Rising Voices Film", "show_id": "s5974", "similarity": 0.6756892776605048}, {"title": "Mad Money", "show_id": "s7370", "similarity": 0.6744356204785764}, {"title": "Anjelah Johnson: Not Fancy", "show_id": "s5895", "similarity": 0.6715562800569002}, {"title": "BELLATOR MMA: Kongo vs. Johnson 2", "show_id": "s38", "similarity": 0.6715470446362188}, {"title": "Knives Out", "show_id": "s5656", "similarity": 0.6690988586261262}]"
-}
-📡 Querying table: mp7bnn9tzhojh7k
-
-🔍 Query params: {'where': '(show_id,eq,"s1")'}
-
-📥 Response status: 200
-
-📥 Request URL: https://mtoft20-potm.hf.space/api/v1/db/data/noco/p9pozkcw81t9aee/mp7bnn9tzhojh7k?where=%28show_id%2Ceq%2C%22s1%22%29
-
-🔄 Trying alternative query format...
-
-📥 Alt response status: 200
-
-📥 Alt request URL: https://mtoft20-potm.hf.space/api/v1/db/data/noco/p9pozkcw81t9aee/mp7bnn9tzhojh7k?where=%28show_id%2Clike%2C%22s1%22%29
-
-Raw response:
-
-{
-"list":[]
-"pageInfo":{
-"totalRows":0
-"page":1
-"pageSize":25
-"isFirstPage":true
-"isLastPage":true
-}
-}
-❌ No entries found in response
-
-Could not parse response as JSON: {"list":[],"pageInfo":{"totalRows":0,"page":1,"pageSize":25,"isFirstPage":true,"isLastPage":true}}
-
-📊 Found 0 matches in table
-
-📋 Table structure for m8e5rglns4acmef:
-
-Columns:
-
-[
-0:"Id"
-1:"CreatedAt"
-2:"UpdatedAt"
-3:"title"
-4:"show_id"
-5:"similar_items"
-]
-Sample row:
-
-{
-"Id":1
-"CreatedAt":"2025-06-02 09:34:10+00:00"
-"UpdatedAt":NULL
-"title":"Man Vs."
-"show_id":"s1751"
-"similar_items":"[{"title": "Settlers", "show_id": "s5", "similarity": 0.7325137795194292}, {"title": "Nature's Weirdest Events", "show_id": "s7575", "similarity": 0.7188299496186253}, {"title": "After Darkness", "show_id": "s2136", "similarity": 0.7141004186676579}, {"title": "Somnus", "show_id": "s6048", "similarity": 0.7099398640829218}, {"title": "Little John", "show_id": "s6801", "similarity": 0.7046743432606751}, {"title": "Shanghai Disney Resort Grand Opening Gala", "show_id": "s295", "similarity": 0.6926804611909125}, {"title": "Before I'm Dead", "show_id": "s5522", "similarity": 0.6857059160224453}, {"title": "Hostile", "show_id": "s4064", "similarity": 0.6842681482307864}, {"title": "The Haunted Hotel", "show_id": "s6793", "similarity": 0.6802541467049906}, {"title": "Star Wars: The Rise of Skywalker (Episode IX)", "show_id": "s531", "similarity": 0.6760391454742809}, {"title": "High-Rise Invasion", "show_id": "s1045", "similarity": 0.6680968736571052}, {"title": "Humans", "show_id": "s2168", "similarity": 0.6671485424786042}, {"title": "The Handmaid's Tale", "show_id": "s764", "similarity": 0.666126348250307}, {"title": "Adam Ruins Everything", "show_id": "s6090", "similarity": 0.6625023465211879}, {"title": "Coherence", "show_id": "s2812", "similarity": 0.6624407207293317}, {"title": "The Vast of Night", "show_id": "s403", "similarity": 0.6600187026296738}, {"title": "Five Grand", "show_id": "s6647", "similarity": 0.6577227564879091}, {"title": "Technotise: Edit & I", "show_id": "s4188", "similarity": 0.6560547168812791}, {"title": "Ghost Walk", "show_id": "s6779", "similarity": 0.6543972382095791}, {"title": "Beyond the Sky", "show_id": "s3086", "similarity": 0.6536638553019316}]"
-}
-📡 Querying table: m8e5rglns4acmef
-
-🔍 Query params: {'where': '(show_id,eq,"s1")'}
-
-📥 Response status: 200
-
-���� Request URL: https://mtoft20-potm.hf.space/api/v1/db/data/noco/p9pozkcw81t9aee/m8e5rglns4acmef?where=%28show_id%2Ceq%2C%22s1%22%29
-
-🔄 Trying alternative query format...
-
-📥 Alt response status: 200
-
-📥 Alt request URL: https://mtoft20-potm.hf.space/api/v1/db/data/noco/p9pozkcw81t9aee/m8e5rglns4acmef?where=%28show_id%2Clike%2C%22s1%22%29
-
-Raw response:
-
-{
-"list":[]
-"pageInfo":{
-"totalRows":0
-"page":1
-"pageSize":25
-"isFirstPage":true
-"isLastPage":true
-}
-}
-❌ No entries found in response
-
-Could not parse response as JSON: {"list":[],"pageInfo":{"totalRows":0,"page":1,"pageSize":25,"isFirstPage":true,"isLastPage":true}}
-
-📊 Found 0 matches in table
-
-📋 Table structure for m2driodimid10k6:
-
-Columns:
-
-[
-0:"Id"
-1:"CreatedAt"
-2:"UpdatedAt"
-3:"title"
-4:"show_id"
-5:"similar_items"
-]
-Sample row:
-
-{
-"Id":1
-"CreatedAt":"2025-06-02 09:34:09+00:00"
-"UpdatedAt":NULL
-"title":"Make This Tonight"
-"show_id":"s1281"
-"similar_items":"[{"title": "Cake Wars", "show_id": "s2428", "similarity": 0.8643776874920789}, {"title": "Tasty 101", "show_id": "s2270", "similarity": 0.851035239717973}, {"title": "Halloween Wars", "show_id": "s1356", "similarity": 0.839582130187393}, {"title": "Giada's Holiday Handbook", "show_id": "s1251", "similarity": 0.8264038541160613}, {"title": "On Chesil Beach", "show_id": "s212", "similarity": 0.821701576024188}, {"title": "Raw. Vegan. Not Gross.", "show_id": "s2018", "similarity": 0.8133997169642753}, {"title": "Crime Scene Kitchen", "show_id": "s684", "similarity": 0.8130779826834713}, {"title": "Worst Cooks in America", "show_id": "s592", "similarity": 0.8117540162729204}, {"title": "Cutthroat Kitchen", "show_id": "s587", "similarity": 0.8111139381056529}, {"title": "Lightened Up", "show_id": "s1280", "similarity": 0.8079789805365294}, {"title": "Chuck's World", "show_id": "s216", "similarity": 0.8049357265970711}, {"title": "Ayesha's Home Kitchen", "show_id": "s1240", "similarity": 0.8013048453237337}, {"title": "Struggle Meals", "show_id": "s1283", "similarity": 0.793547594830839}, {"title": "TrueSouth", "show_id": "s869", "similarity": 0.7906473317607992}, {"title": "Behind The Dish", "show_id": "s1279", "similarity": 0.7876233721299817}, {"title": "Eater's Guide to the World", "show_id": "s1212", "similarity": 0.7800859117925178}, {"title": "Supermarket Stakeout", "show_id": "s1367", "similarity": 0.7786342300343229}, {"title": "The Grill Iron", "show_id": "s1284", "similarity": 0.7781488386934403}, {"title": "F*ck, That's Delicious", "show_id": "s1308", "similarity": 0.7778297208530904}, {"title": "Jamie: Keep Cooking and Carry On", "show_id": "s1496", "similarity": 0.7756508905864695}]"
-}
-📡 Querying table: m2driodimid10k6
-
-🔍 Query params: {'where': '(show_id,eq,"s1")'}
-
-📥 Response status: 200
-
-📥 Request URL: https://mtoft20-potm.hf.space/api/v1/db/data/noco/p9pozkcw81t9aee/m2driodimid10k6?where=%28show_id%2Ceq%2C%22s1%22%29
-
-🔄 Trying alternative query format...
-
-📥 Alt response status: 200
-
-📥 Alt request URL: https://mtoft20-potm.hf.space/api/v1/db/data/noco/p9pozkcw81t9aee/m2driodimid10k6?where=%28show_id%2Clike%2C%22s1%22%29
-
-Raw response:
-
-{
-"list":[]
-"pageInfo":{
-"totalRows":0
-"page":1
-"pageSize":25
-"isFirstPage":true
-"isLastPage":true
-}
-}
-❌ No entries found in response
-
-Could not parse response as JSON: {"list":[],"pageInfo":{"totalRows":0,"page":1,"pageSize":25,"isFirstPage":true,"isLastPage":true}}
-
-📊 Found 0 matches in table
-
-📝 Total similar items found: 0
-
-No similar content found.
+import streamlit as st
+import requests
+import pandas as pd
+from together import Together
+import os
+import json
+from collections import defaultdict
+import re
+
+# =============================================================================
+# CONFIGURATION - Using Secrets Management
+# =============================================================================
+NOCODB_URL = "https://mtoft20-potm.hf.space/api/v1/db/data/noco/p9pozkcw81t9aee/mvtt3arw5ni7uqp"  # Updated with table ID
+
+# Get sensitive data from Streamlit secrets or environment variables
+def get_api_credentials():
+    """Get API credentials from secrets or environment"""
+    try:
+        # Try Streamlit secrets first (for Hugging Face Spaces)
+        api_token = st.secrets.get("NOCODB_API_TOKEN", os.environ.get("NOCODB_API_TOKEN", ""))
+        together_key = st.secrets.get("TOGETHER_API_KEY", os.environ.get("TOGETHER_API_KEY", ""))
+        
+        return api_token, together_key
+    except:
+        # Fallback to environment variables
+        api_token = os.environ.get("NOCODB_API_TOKEN", "")
+        together_key = os.environ.get("TOGETHER_API_KEY", "")
+        
+        return api_token, together_key
+
+# Initialize Together AI client
+@st.cache_resource
+def get_ai_client():
+    """Initialize Together AI client"""
+    _, together_key = get_api_credentials()
+    if not together_key:
+        st.error("Together AI API key not found. Please configure it in the secrets.")
+        return None
+    return Together(api_key=together_key)
+
+# =============================================================================
+# HELPER FUNCTIONS
+# =============================================================================
+@st.cache_data(ttl=300)  # Cache for 5 minutes
+def get_streaming_content():
+    """Fetch streaming content from NocoDB with pagination"""
+    api_token, _ = get_api_credentials()
+    
+    if not api_token:
+        st.error("NocoDB credentials not configured. Please set up your secrets.")
+        return []
+    
+    headers = {
+        "xc-token": api_token,
+        "accept": "application/json"
+    }
+    
+    all_content = []
+    page = 1
+    page_size = 1000  # NocoDB default page size
+    
+    try:
+        while True:
+            offset = (page - 1) * page_size
+            url = f"{NOCODB_URL}?limit={page_size}&offset={offset}"
+            
+            response = requests.get(url, headers=headers)
+            
+            if response.status_code == 200:
+                data = response.json()
+                current_page_data = data.get('list', [])
+                
+                # Filter out None values and ensure all items are dictionaries
+                current_page_data = [item for item in current_page_data if item and isinstance(item, dict)]
+                
+                if not current_page_data:  # No more data to fetch
+                    break
+                    
+                all_content.extend(current_page_data)
+                
+                # Check if this is the last page
+                page_info = data.get('pageInfo', {})
+                if page_info.get('isLastPage', True):
+                    break
+                
+                page += 1
+            else:
+                st.error(f"Failed to fetch data: {response.status_code}")
+                if not all_content:  # Only return [] if we haven't fetched any data
+                    return []
+                break  # If we have some data, return what we've got
+                
+        return all_content
+            
+    except Exception as e:
+        st.error(f"Error connecting to database: {str(e)}")
+        st.write("Full error details:", e)
+        return []
+
+def filter_content(content_list, filters):
+    """Apply filters to streaming content list"""
+    filtered = []
+    
+    for content in content_list:
+        if not content or not isinstance(content, dict):
+            continue
+            
+        matches_all_filters = True
+        
+        # Streaming service filter
+        if filters['streaming_services']:
+            if content.get('streaming_service') not in filters['streaming_services']:
+                matches_all_filters = False
+                continue
+        
+        # Type filter - only apply if not "All"
+        if filters['content_type']:
+            if content.get('type') != filters['content_type']:
+                matches_all_filters = False
+                continue
+            
+        # Genre filter - check if ALL selected genres are in the content's genres
+        if filters['genres']:
+            content_genres = set(g.strip().lower() for g in str(content.get('listed_in', '')).split(','))
+            selected_genres = set(g.strip().lower() for g in filters['genres'])
+            
+            if not selected_genres.issubset(content_genres):
+                matches_all_filters = False
+                continue
+            
+        # Rating filter
+        if filters['ratings']:
+            rating = content.get('rating', '').strip()
+            # Only compare if rating is a valid string and not a duration
+            if not rating or not isinstance(rating, str) or rating.endswith('min'):
+                matches_all_filters = False
+                continue
+            if rating not in filters['ratings']:
+                matches_all_filters = False
+                continue
+
+        # Release year filter
+        try:
+            release_year = int(content.get('release_year', 0))
+            if release_year < filters['year_range'][0] or release_year > filters['year_range'][1]:
+                matches_all_filters = False
+                continue
+        except (ValueError, TypeError):
+            matches_all_filters = False
+            continue
+            
+        # Duration filter (different handling for movies)
+        if filters['content_type'] == 'Movie':
+            duration = str(content.get('duration', ''))
+            if 'min' in duration:
+                try:
+                    minutes = int(duration.split()[0])
+                    if minutes < filters['duration_range'][0] or minutes > filters['duration_range'][1]:
+                        matches_all_filters = False
+                        continue
+                except (ValueError, IndexError):
+                    matches_all_filters = False
+                    continue
+
+        # Director filter (optional)
+        if filters['director']:
+            director = str(content.get('director', '')).lower()
+            if not any(name.strip().lower() in director for name in filters['director'].split(',')):
+                matches_all_filters = False
+                continue
+
+        # Cast filter (optional)
+        if filters['cast']:
+            cast = str(content.get('cast', '')).lower()
+            if not any(name.strip().lower() in cast for name in filters['cast'].split(',')):
+                matches_all_filters = False
+                continue
+        
+        if matches_all_filters:
+            filtered.append(content)
+    
+    return filtered
+
+def create_content_context(content_list):
+    """Create context string about current content for AI"""
+    if not content_list:
+        return "No content matches the current filters."
+    
+    total = len(content_list)
+    movies = sum(1 for c in content_list if c.get('type') == 'Movie')
+    shows = sum(1 for c in content_list if c.get('type') == 'TV Show')
+    
+    context = f"""Currently showing {total} titles ({movies} movies and {shows} TV shows). """
+    
+    # Add some genre info
+    all_genres = []
+    for content in content_list[:20]:  # Sample from first 20 items
+        genres = content.get('listed_in', '').split(', ')
+        all_genres.extend(genres)
+    
+    if all_genres:
+        genre_counts = pd.Series(all_genres).value_counts()
+        top_genres = genre_counts.head(5).index.tolist()
+        context += f"Top genres include: {', '.join(top_genres)}. "
+    
+    # Add year range
+    years = [int(c.get('release_year', 0)) for c in content_list if c.get('release_year')]
+    if years:
+        context += f"Release years range from {min(years)} to {max(years)}."
+    
+    return context
+
+def get_ai_response(client, question, context, model_name):
+    """Get response from Together AI"""
+    try:
+        prompt = f"""You are a helpful streaming content expert. Based on the current content data, please answer the user's question accurately and helpfully.
+
+Current Content Data Context:
+{context}
+
+User Question: {question}
+
+Please provide a helpful, accurate response based on the data provided. Keep your answer concise but informative."""
+
+        response = client.chat.completions.create(
+            model=model_name,
+            messages=[
+                {"role": "system", "content": "You are a helpful content expert with deep knowledge of movies and TV shows."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=300,
+            temperature=0.7,
+        )
+        
+        return response.choices[0].message.content
+        
+    except Exception as e:
+        raise Exception(f"Together AI Error: {str(e)}")
+
+def extract_unique_names(content_list, field):
+    """Extract unique names from a comma-separated field in content list"""
+    unique_names = set()
+    for content in content_list:
+        names = content.get(field, '')
+        if names:
+            # Split by comma and clean each name
+            for name in names.split(','):
+                cleaned_name = name.strip()
+                if cleaned_name:  # Only add non-empty names
+                    unique_names.add(cleaned_name)
+    return sorted(list(unique_names))
+
+def get_similar_content(content, n_recommendations=5):
+    """Get pre-computed similar content from database"""
+    try:
+        # Get database credentials
+        api_token, _ = get_api_credentials()
+        headers = {
+            "xc-token": api_token,
+            "accept": "application/json"
+        }
+        
+        # Debug: Print the title and show_id we're searching for
+        title = content.get('title', '')
+        show_id = content.get('show_id', '')
+        st.write(f"🔍 Searching for similar content to: {title} (ID: {show_id})")
+        
+        # Base URL for the NocoDB API
+        base_url = "https://mtoft20-potm.hf.space/api/v1/db/data/noco/p9pozkcw81t9aee"
+        
+        # URLs for both similarity tables using table IDs
+        similarity_table_urls = [
+            f"{base_url}/mp7bnn9tzhojh7k",  # Part 1 similarities
+            f"{base_url}/m8e5rglns4acmef",   # Part 2 similarities
+            f"{base_url}/m2driodimid10k6"    # Part 3 similarities
+        ]
+        
+        similar_items = []
+        
+        # Check both tables for similarities
+        for table_url in similarity_table_urls:
+            # Debug: Get a sample row to see table structure
+            sample_params = {
+                "limit": 1
+            }
+            sample_response = requests.get(table_url, headers=headers, params=sample_params)
+            if sample_response.status_code == 200:
+                sample_data = sample_response.json()
+                if sample_data.get('list'):
+                    st.write(f"📋 Table structure for {table_url.split('/')[-1]}:")
+                    st.write("Columns:", list(sample_data['list'][0].keys()))
+                    st.write("Sample row:", sample_data['list'][0])
+            
+            # Try finding by show_id first
+            query = f'(show_id,eq,"{show_id}")'
+            params = {
+                "where": query
+            }
+            
+            # Debug: Print the request details
+            st.write(f"📡 Querying table: {table_url.split('/')[-1]}")
+            st.write(f"🔍 Query params: {params}")
+            
+            # Try first query format
+            try:
+                response = requests.get(table_url, headers=headers, params=params)
+                st.write(f"📥 Response status: {response.status_code}")
+                st.write("📥 Request URL:", response.url)
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    if not data.get('list'):
+                        # If no results with show_id, try by title
+                        st.write("🔄 No results with show_id, trying title search...")
+                        title_query = f'(title,eq,"{title}")'
+                        title_params = {
+                            "where": title_query
+                        }
+                        response = requests.get(table_url, headers=headers, params=title_params)
+                        st.write(f"📥 Title search response status: {response.status_code}")
+                        st.write("📥 Title search URL:", response.url)
+                        if response.status_code == 200:
+                            data = response.json()
+                
+                # Debug: Print raw response
+                try:
+                    response_json = response.json()
+                    st.write("Raw response:", response_json)
+                    
+                    # Additional debugging
+                    if response_json.get('list'):
+                        st.write("✅ Found entries in response")
+                        for entry in response_json['list']:
+                            st.write(f"Entry title: {entry.get('title')}, show_id: {entry.get('show_id')}")
+                    else:
+                        st.write("❌ No entries found in response")
+                        
+                        # Try to get a few random entries to verify data
+                        sample_params = {
+                            "limit": 3,
+                            "shuffle": True
+                        }
+                        sample_response = requests.get(table_url, headers=headers, params=sample_params)
+                        if sample_response.status_code == 200:
+                            sample_data = sample_response.json()
+                            st.write("🔍 Random entries from table:")
+                            for entry in sample_data.get('list', []):
+                                st.write(f"- {entry.get('title')} (ID: {entry.get('show_id')})")
+                    
+                except Exception as e:
+                    st.write("Could not parse response as JSON:", response.text)
+                
+                if response.status_code == 200:
+                    data = response_json
+                    st.write(f"📊 Found {len(data.get('list', []))} matches in table")
+                    
+                    if data and len(data.get('list', [])) > 0:
+                        # Get similar items from stored data
+                        try:
+                            table_items = json.loads(data['list'][0]['similar_items'])
+                            st.write(f"✅ Successfully parsed {len(table_items)} similar items")
+                            similar_items.extend(table_items)
+                        except Exception as parse_error:
+                            st.write(f"❌ Error parsing similar items: {str(parse_error)}")
+                            st.write("Raw data:", data['list'][0])
+            except Exception as e:
+                st.write(f"❌ Request error: {str(e)}")
+        
+        st.write(f"📝 Total similar items found: {len(similar_items)}")
+        
+        if similar_items:
+            # Sort by similarity score and limit to requested number
+            similar_items.sort(key=lambda x: x['similarity'], reverse=True)
+            similar_items = similar_items[:n_recommendations]
+            
+            # Get full content details for each similar item
+            similar_content = []
+            for item in similar_items:
+                # Query main content table for full details using show_id if available
+                show_id = item.get('show_id', '')
+                if show_id:
+                    query = f'(show_id,eq,"{show_id}")'
+                else:
+                    # Fallback to title if show_id not available
+                    query = f'(title,eq,"{item["title"]}")'
+                    
+                content_params = {
+                    "where": query
+                }
+                content_response = requests.get(NOCODB_URL, headers=headers, params=content_params)
+                
+                if content_response.status_code == 200:
+                    content_data = content_response.json()
+                    if content_data and len(content_data.get('list', [])) > 0:
+                        content_dict = content_data['list'][0]
+                        content_dict['similarity'] = f"{item['similarity']:.2%}"
+                        similar_content.append(content_dict)
+                        st.write(f"✅ Found details for: {item['title']}")
+                    else:
+                        st.write(f"❌ No content details found for: {item['title']}")
+            
+            return similar_content
+        
+        return []
+    except Exception as e:
+        st.error(f"Error fetching similar content: {str(e)}")
+        st.write("Full error details:", e)
+        return []
+
+# =============================================================================
+# MAIN APP
+# =============================================================================
+def main():
+    # Page config
+    st.set_page_config(
+        page_title="Streaming Content Explorer",
+        page_icon="🎬",
+        layout="wide"
+    )
+    
+    # Header
+    st.title("🎬 Streaming Content Explorer")
+    st.write("Explore movies and TV shows across multiple streaming platforms!")
+    
+    # Check API credentials
+    api_token, together_key = get_api_credentials()
+    
+    if not together_key:
+        st.error("⚠️ Together AI API key not configured!")
+        st.info("Please set your TOGETHER_API_KEY in the Hugging Face Spaces secrets.")
+        st.stop()
+    
+    if not api_token:
+        st.error("⚠️ NocoDB credentials not configured!")
+        st.info("Please set NOCODB_API_TOKEN in the Hugging Face Spaces secrets.")
+        st.stop()
+    
+    # Initialize AI client
+    try:
+        client = get_ai_client()
+        if not client:
+            st.stop()
+    except Exception as e:
+        st.error(f"Failed to initialize Together AI client: {e}")
+        st.stop()
+    
+    # Load all content first
+    with st.spinner("Loading streaming content..."):
+        all_content = get_streaming_content()
+    
+    if not all_content:
+        st.error("Could not load streaming content. Please check your NocoDB connection.")
+        st.stop()
+    
+    # Extract unique values for filters
+    all_ratings = sorted(list(set(
+        c.get('rating') for c in all_content 
+        if c and isinstance(c, dict) 
+        and c.get('rating') 
+        and isinstance(c.get('rating'), str)
+        and not c.get('rating').endswith('min')  # Exclude duration values
+        and c.get('rating').strip()  # Exclude empty strings
+    )))
+    all_genres = sorted(list(set(
+        genre.strip()
+        for c in all_content
+        for genre in c.get('listed_in', '').split(',')
+        if genre.strip()
+    )))
+    all_streaming_services = sorted(list(set([c.get('streaming_service') for c in all_content if c.get('streaming_service')])))
+    
+    # Extract unique directors and cast members
+    all_directors = extract_unique_names(all_content, 'director')
+    all_cast_members = extract_unique_names(all_content, 'cast')
+    
+    # Sidebar filters
+    st.sidebar.header("🔍 Filter Content")
+
+    with st.sidebar.form("filter_form"):
+        st.subheader("Streaming Services")
+        
+        # Streaming service selection (required)
+        selected_services = st.multiselect(
+            "Select Your Streaming Services",
+            options=all_streaming_services,
+            default=all_streaming_services[:1],  # Default to first service
+            help="Select the streaming services you have access to",
+            key="streaming_services"
+        )
+        
+        if not selected_services:
+            st.warning("Please select at least one streaming service")
+        
+        st.subheader("Content Filters")
+        
+        content_type = st.selectbox(
+            "Content Type",
+            options=["All", "Movie", "TV Show"],
+            index=0
+        )
+        
+        selected_genres = st.multiselect(
+            "Genres",
+            options=all_genres,
+            default=[]
+        )
+
+        st.subheader("Optional Filters")
+        
+        # Rating filter
+        selected_ratings = st.multiselect(
+            "Ratings",
+            options=all_ratings,
+            default=[],
+            help="Filter by content rating"
+        )
+
+        # Year range slider
+        years = [int(c.get('release_year', 0)) for c in all_content if c.get('release_year')]
+        min_year, max_year = min(years), max(years)
+        year_range = st.slider(
+            "Release Year",
+            min_value=min_year,
+            max_value=max_year,
+            value=(min_year, max_year),
+            help="Filter by release year range"
+        )
+        
+        # Duration range slider (for movies only)
+        movie_durations = [
+            int(str(c.get('duration', '0 min')).split()[0])
+            for c in all_content
+            if c and c.get('type') == 'Movie' and 'min' in str(c.get('duration', ''))
+        ]
+        
+        if movie_durations:
+            min_duration = min(d for d in movie_durations if d > 0)
+            max_duration = max(movie_durations)
+            duration_range = st.slider(
+                "Movie Duration (minutes)",
+                min_value=min_duration,
+                max_value=max_duration,
+                value=(min_duration, max_duration),
+                help="This filter only applies to movies"
+            )
+        else:
+            duration_range = (0, 1000)  # Fallback values
+
+        # Director filter with autocomplete
+        selected_directors = st.multiselect(
+            "Directors",
+            options=all_directors,
+            default=[],
+            help="Select one or more directors (searchable)",
+            placeholder="Start typing to search directors..."
+        )
+
+        # Cast filter with autocomplete
+        selected_cast = st.multiselect(
+            "Cast Members",
+            options=all_cast_members,
+            default=[],
+            help="Select one or more cast members (searchable)",
+            placeholder="Start typing to search cast members..."
+        )
+        
+        # Submit button
+        apply_filters = st.form_submit_button("🔍 Apply Filters", type="primary")
+    
+    # Create filter dictionary
+    filters = {
+        'streaming_services': selected_services,
+        'content_type': content_type if content_type != "All" else None,
+        'ratings': selected_ratings,
+        'genres': selected_genres,
+        'year_range': year_range,
+        'duration_range': duration_range,
+        'director': ','.join(selected_directors) if selected_directors else '',
+        'cast': ','.join(selected_cast) if selected_cast else ''
+    }
+    
+    # Only apply filters when the button is clicked
+    if apply_filters:
+        filtered_content = filter_content(all_content, filters)
+        st.session_state.filtered_content = filtered_content
+    else:
+        # Initialize filtered content if not exists
+        if 'filtered_content' not in st.session_state:
+            st.session_state.filtered_content = all_content
+
+    # Main content area
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        # Content listings
+        filtered_count = len(st.session_state.filtered_content)
+        if filtered_count == 0:
+            st.subheader("📋 No Titles Found")
+        else:
+            # Header with count and page info
+            st.subheader(f"📋 Found {filtered_count:,} Title{'s' if filtered_count != 1 else ''}")
+        
+        if st.session_state.filtered_content:
+            # Active Filters section with better formatting
+            if any([filters['content_type'], filters['genres'], filters['ratings'], 
+                   filters['director'], filters['cast']]):
+                with st.expander("🔍 Active Filters", expanded=True):
+                    filter_cols = st.columns(2)
+                    with filter_cols[0]:
+                        if filters['content_type']:
+                            st.write(f"**Type:** {filters['content_type']}")
+                        if filters['genres']:
+                            st.write(f"**Genres:** {', '.join(filters['genres'])}")
+                        if filters['ratings']:
+                            st.write(f"**Ratings:** {', '.join(filters['ratings'])}")
+                    with filter_cols[1]:
+                        if filters['director']:
+                            st.write(f"**Director:** {filters['director']}")
+                        if filters['cast']:
+                            st.write(f"**Cast:** {filters['cast']}")
+            st.write("---")
+
+            # Pagination setup
+            items_per_page = 10
+            total_pages = (filtered_count + items_per_page - 1) // items_per_page
+
+            # Initialize page number in session state if not exists
+            if 'current_page' not in st.session_state:
+                st.session_state.current_page = 1
+
+            # Calculate slice indices for current page
+            start_idx = (st.session_state.current_page - 1) * items_per_page
+            end_idx = min(start_idx + items_per_page, filtered_count)
+            
+            # Display current range info
+            st.write(f"Showing {start_idx + 1}-{end_idx} of {filtered_count:,} titles")
+            
+            # Show items for current page
+            for i, content in enumerate(st.session_state.filtered_content[start_idx:end_idx], start=start_idx):
+                with st.expander(f"{content.get('title', 'N/A')} ({content.get('release_year', 'N/A')})"):
+                    # Content details in columns
+                    detail_col1, detail_col2 = st.columns(2)
+                    
+                    with detail_col1:
+                        st.write(f"**📺 Available on:** {content.get('streaming_service', 'N/A')}")
+                        st.write(f"**🎭 Type:** {content.get('type', 'N/A')}")
+                        st.write(f"**⭐ Rating:** {content.get('rating', 'N/A')}")
+                        st.write(f"**⏱️ Duration:** {content.get('duration', 'N/A')}")
+                    
+                    with detail_col2:
+                        st.write(f"**🎬 Genres:** {content.get('listed_in', 'N/A')}")
+                        cast = content.get('cast')
+                        cast_display = cast[:100] + "..." if cast and len(cast) > 100 else cast if cast else "N/A"
+                        st.write(f"**👥 Cast:** {cast_display}")
+                        st.write(f"**📝 Director:** {content.get('director', 'N/A')}")
+                    
+                    # Description
+                    st.write(f"**📖 Description:**")
+                    st.write(content.get('description', 'N/A'))
+                    
+                    # Add Find Similar button with loading state
+                    similar_button = st.button(f"🔍 Find Similar Content", key=f"similar_{i}")
+                    if similar_button:
+                        with st.spinner("Finding similar content..."):
+                            similar_content = get_similar_content(content)
+                            
+                            if similar_content:
+                                # Create tabs for different aspects of recommendations
+                                sim_tab1, sim_tab2 = st.tabs(["📺 Similar Titles", "🔍 Why These Recommendations"])
+                                
+                                with sim_tab1:
+                                    for sim_content in similar_content:
+                                        with st.container():
+                                            col1, col2 = st.columns([3, 1])
+                                            with col1:
+                                                st.write(f"**{sim_content.get('title')}** ({sim_content.get('type')}, {sim_content.get('release_year')})")
+                                                st.write(f"*Available on:* {sim_content.get('streaming_service')}")
+                                                st.write(f"*Genres:* {sim_content.get('listed_in')}")
+                                            with col2:
+                                                st.write(f"**Match:** {sim_content.get('similarity', 'N/A')}")
+                                            
+                                            with st.expander("See more details"):
+                                                st.write(f"**Cast:** {sim_content.get('cast', 'N/A')}")
+                                                st.write(f"**Director:** {sim_content.get('director', 'N/A')}")
+                                                st.write(f"**Description:** {sim_content.get('description', 'N/A')}")
+                                            st.write("---")
+                                
+                                with sim_tab2:
+                                    st.write("**Why these recommendations?**")
+                                    st.write("""
+                                    These recommendations are pre-computed using advanced content analysis:
+                                    - Genre and theme matching
+                                    - Plot similarity analysis
+                                    - Cast and director relationships
+                                    - Release year proximity
+                                    
+                                    The percentage match indicates how similar each title is to your selection.
+                                    """)
+                            else:
+                                st.info("No similar content found.")
+            
+            # Bottom pagination controls with better layout
+            st.write("---")
+            page_cols = st.columns([1, 2, 1, 2, 1])
+            
+            # Previous button
+            with page_cols[0]:
+                if st.button("← Previous", disabled=st.session_state.current_page == 1, use_container_width=True):
+                    st.session_state.current_page -= 1
+                    st.rerun()
+            
+            # Spacer
+            with page_cols[1]:
+                st.write("")
+            
+            # Page input
+            with page_cols[2]:
+                page_input = st.number_input(
+                    f"Page (of {total_pages})",
+                    min_value=1,
+                    max_value=total_pages,
+                    value=st.session_state.current_page,
+                    key="page_number",
+                    help=f"Enter a page number between 1 and {total_pages}"
+                )
+                if page_input != st.session_state.current_page:
+                    st.session_state.current_page = page_input
+                    st.rerun()
+            
+            # Spacer
+            with page_cols[3]:
+                st.write("")
+            
+            # Next button
+            with page_cols[4]:
+                if st.button("Next →", disabled=st.session_state.current_page == total_pages, use_container_width=True):
+                    st.session_state.current_page += 1
+                    st.rerun()
+        else:
+            st.info("No content matches your current filters. Try adjusting the criteria.")
+    
+    with col2:
+        # AI Chat Section
+        st.subheader("🤖 Ask AI Assistant")
+        st.write("Ask questions about the streaming content!")
+        
+        # Model selection for Together AI
+        model_choice = st.selectbox(
+            "Select AI Model:",
+            [
+                "google/gemma-2b-it",
+                "google/gemma-2-27b-it",
+                "mistralai/Mistral-7B-Instruct-v0.1",
+                "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",
+                "mistralai/Mixtral-8x7B-Instruct-v0.1"
+            ],
+            help="Select an AI model to answer your questions"
+        )
+        
+        # Example questions
+        with st.expander("💡 Example Questions"):
+            st.write("• What are the most common genres?")
+            st.write("• What's the average movie duration?")
+            st.write("• Which directors have the most content?")
+            st.write("• What are the trends in content ratings?")
+            st.write("• Tell me about the release year distribution")
+        
+        user_question = st.text_area(
+            "Your Question:",
+            placeholder="Ask about genres, ratings, directors, trends...",
+            height=100
+        )
+        
+        if st.button("🔍 Ask AI", type="primary"):
+            if user_question:
+                with st.spinner("AI is analyzing the content..."):
+                    # Create context from current filtered data
+                    context = create_content_context(st.session_state.filtered_content)
+                    
+                    try:
+                        # Get AI response
+                        ai_response = get_ai_response(client, user_question, context, model_choice)
+                        
+                        st.success("**AI Assistant Response:**")
+                        st.write(ai_response)
+                        
+                        # Show debug info
+                        with st.expander("Debug Info"):
+                            st.write(f"Model used: {model_choice}")
+                            st.write(f"Content items analyzed: {len(st.session_state.filtered_content)}")
+                            st.write(f"Context: {context[:150]}...")
+                        
+                    except Exception as e:
+                        st.error(f"AI Error: {str(e)}")
+                        
+                        # Fallback response with data analysis
+                        st.info("**Fallback Analysis:**")
+                        if st.session_state.filtered_content:
+                            movies = sum(1 for c in st.session_state.filtered_content if c.get('type') == 'Movie')
+                            shows = sum(1 for c in st.session_state.filtered_content if c.get('type') == 'TV Show')
+                            st.write(f"• Found {len(st.session_state.filtered_content)} titles ({movies} movies, {shows} TV shows)")
+                            
+                            # Show top genres
+                            genres = [g.strip() for c in st.session_state.filtered_content for g in c.get('listed_in', '').split(',')]
+                            genre_counts = pd.Series(genres).value_counts()
+                            st.write(f"• Top genres: {', '.join(genre_counts.head(3).index)}")
+                            
+                            # Show year range
+                            years = [int(c.get('release_year', 0)) for c in st.session_state.filtered_content if c.get('release_year')]
+                            if years:
+                                st.write(f"• Release years: {min(years)} - {max(years)}")
+            else:
+                st.warning("Please enter a question first!")
+    
+    # Footer stats with improved layout
+    st.markdown("---")
+    if all_content:
+        total_items = len(all_content)
+        filtered_items = len(st.session_state.filtered_content)
+        
+        # Create columns for stats with better spacing
+        stat_cols = st.columns(len(selected_services) + 3)
+        
+        # Basic stats with improved formatting
+        with stat_cols[0]:
+            st.metric("📊 Total Available", f"{total_items:,}")
+        
+        with stat_cols[1]:
+            st.metric("🔍 Filtered Results", f"{filtered_items:,}")
+        
+        with stat_cols[2]:
+            movies = sum(1 for c in st.session_state.filtered_content if c.get('type') == 'Movie')
+            shows = sum(1 for c in st.session_state.filtered_content if c.get('type') == 'TV Show')
+            st.metric("🎬 Movies / 📺 Shows", f"{movies:,} / {shows:,}")
+        
+        # Streaming service breakdown with icons
+        service_icons = {
+            "Netflix": "🔴",
+            "Amazon Prime": "🔵",
+            "Hulu": "🟢",
+            "Disney+": "🟣"
+        }
+        
+        for i, service in enumerate(selected_services, 3):
+            if i < len(stat_cols):
+                service_count = sum(1 for c in st.session_state.filtered_content if c.get('streaming_service') == service)
+                icon = service_icons.get(service, "📺")
+                with stat_cols[i]:
+                    st.metric(f"{icon} {service}", f"{service_count:,}")
+
+if __name__ == "__main__":
+    main()