Update src/streamlit_app.py

src/streamlit_app.py

@@ -6,232 +6,161 @@ import os
 import json
 
 # =============================================================================
-# CONFIGURATION - Using Secrets Management
+# CONFIGURATION
 # =============================================================================
-NOCODB_URL = "https://mtoft20-potm.hf.space".strip()  # Base URL, ensure no extra spaces
+NOCODB_URL = "https://mtoft20-potm.hf.space".strip()
 
-# Get sensitive data from Streamlit secrets or environment variables
+# =============================================================================
+# API CLIENTS & CREDENTIALS
+# =============================================================================
 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", "")).strip()
-        together_key = st.secrets.get("TOGETHER_API_KEY", os.environ.get("TOGETHER_API_KEY", "")).strip()
-        
-        # Get endpoints for content and similarities
-        content_endpoint = st.secrets.get("NOCODB_CONTENT_ENDPOINT", os.environ.get("NOCODB_CONTENT_ENDPOINT", "")).strip()
-        similarity_endpoints = [endpoint.strip() for endpoint in 
-                             st.secrets.get("NOCODB_SIMILARITY_ENDPOINTS", 
-                                          os.environ.get("NOCODB_SIMILARITY_ENDPOINTS", "")).split(",")
-                             if endpoint.strip()]
-        
-        return api_token, together_key, content_endpoint, similarity_endpoints
-    except:
-        # Fallback to environment variables
-        api_token = os.environ.get("NOCODB_API_TOKEN", "").strip()
-        together_key = os.environ.get("TOGETHER_API_KEY", "").strip()
-        content_endpoint = os.environ.get("NOCODB_CONTENT_ENDPOINT", "").strip()
-        similarity_endpoints = [endpoint.strip() for endpoint in 
-                             os.environ.get("NOCODB_SIMILARITY_ENDPOINTS", "").split(",")
-                             if endpoint.strip()]
-        
-        return api_token, together_key, content_endpoint, similarity_endpoints
+    """Get API credentials and endpoints from secrets or environment."""
+    def get_secret(key):
+        """Helper to get and clean secret values."""
+        return st.secrets.get(key, os.environ.get(key, "")).strip()
+    
+    def get_endpoints(key):
+        """Helper to get and clean endpoint lists."""
+        return [ep.strip() for ep in get_secret(key).split(",") if ep.strip()]
+    
+    return {
+        'api_token': get_secret("NOCODB_API_TOKEN"),
+        'together_key': get_secret("TOGETHER_API_KEY"),
+        'content_endpoint': get_secret("NOCODB_CONTENT_ENDPOINT"),
+        'similarity_endpoints': get_endpoints("NOCODB_SIMILARITY_ENDPOINTS")
+    }
 
-# Initialize Together AI client
 @st.cache_resource
 def get_ai_client():
-    """Initialize Together AI client"""
-    _, together_key, _, _ = get_api_credentials()
-    if not together_key:
+    """Initialize Together AI client."""
+    creds = get_api_credentials()
+    if not creds['together_key']:
         st.error("Together AI API key not found. Please configure it in the secrets.")
         return None
-    return Together(api_key=together_key)
+    return Together(api_key=creds['together_key'])
 
 # =============================================================================
-# HELPER FUNCTIONS
+# DATABASE OPERATIONS
 # =============================================================================
-@st.cache_data(ttl=300)  # Cache for 5 minutes
+def make_api_request(url, headers, params=None):
+    """Make API request with error handling."""
+    try:
+        response = requests.get(url, headers=headers, params=params)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"API request failed: {str(e)}")
+        return None
+
+@st.cache_data(ttl=300)
 def get_streaming_content():
-    """Fetch streaming content from NocoDB with pagination"""
-    api_token, _, content_endpoint, _ = get_api_credentials()
+    """Fetch streaming content from NocoDB with pagination."""
+    creds = get_api_credentials()
     
-    if not api_token or not content_endpoint:
+    if not creds['api_token'] or not creds['content_endpoint']:
         st.error("NocoDB credentials not configured. Please set up your secrets.")
         return []
     
     headers = {
-        "xc-token": api_token,
+        "xc-token": creds['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.strip()}{content_endpoint.strip()}?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', [])
-                
-                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 = []
+    page_size = 1000
     
-    for content in content_list:
-        if not content or not isinstance(content, dict):
-            continue
-            
-        matches_all_filters = True
+    while True:
+        url = f"{NOCODB_URL}{creds['content_endpoint']}?limit={page_size}&offset={(page-1)*page_size}"
+        data = make_api_request(url, headers)
         
-        # 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
+        if not data:
+            break
             
-        # 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
+        current_page = data.get('list', [])
+        if not current_page:
+            break
             
-        # 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
+        all_content.extend(current_page)
         
-        if matches_all_filters:
-            filtered.append(content)
+        if data.get('pageInfo', {}).get('isLastPage', True):
+            break
+            
+        page += 1
     
-    return filtered
+    return all_content
 
-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')
+def get_similar_content(content, n_recommendations=5):
+    """Get pre-computed similar content from database."""
+    creds = get_api_credentials()
     
-    context = f"""Currently showing {total} titles ({movies} movies and {shows} TV shows). """
+    if not creds['api_token'] or not creds['similarity_endpoints']:
+        st.error("NocoDB credentials not configured properly.")
+        return []
     
-    # 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)
+    headers = {
+        "xc-token": creds['api_token'],
+        "accept": "application/json"
+    }
     
-    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)}. "
+    # Build query parameters
+    query = {
+        "where": f'(show_id,eq,{content.get("show_id", "")})~and(title,eq,{content.get("title", "")})'
+    }
     
-    # 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)}."
+    # Search through similarity endpoints
+    for endpoint in creds['similarity_endpoints']:
+        url = f"{NOCODB_URL}{endpoint}"
+        data = make_api_request(url, headers, query)
+        
+        if not data or not data.get('list'):
+            continue
+            
+        # Process similar items
+        for entry in data['list']:
+            try:
+                similar_items = json.loads(entry['similar_items'])
+                similar_content = []
+                
+                # Get details for each similar item
+                for item in similar_items[:n_recommendations]:
+                    content_query = {
+                        "where": f'(show_id,eq,{item.get("show_id", "")})'
+                    }
+                    content_url = f"{NOCODB_URL}{creds['content_endpoint']}"
+                    content_data = make_api_request(content_url, headers, content_query)
+                    
+                    if content_data and content_data.get('list'):
+                        content_dict = content_data['list'][0]
+                        content_dict['similarity'] = f"{item['similarity']:.2%}"
+                        similar_content.append(content_dict)
+                
+                return similar_content[:n_recommendations]
+            except (json.JSONDecodeError, KeyError, IndexError):
+                continue
     
-    return context
+    return []
 
+# =============================================================================
+# AI OPERATIONS
+# =============================================================================
 def get_ai_response(client, question, context, model_name):
-    """Get response from Together AI"""
+    """Get AI response for user questions."""
     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.
+        prompt = f"""You are a sophisticated butler and streaming content expert. Based on the current content data, 
+        please assist the user with their entertainment needs.
 
 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."""
+Please provide a refined and helpful response, keeping it concise yet 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": "system", "content": "You are StreamButler, a sophisticated entertainment concierge with extensive knowledge of films and television."},
                 {"role": "user", "content": prompt}
             ],
             max_tokens=300,
@@ -241,165 +170,101 @@ Please provide a helpful, accurate response based on the data provided. Keep you
         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))
+        raise Exception(f"AI Service Error: {str(e)}")
 
-def get_similar_content(content, n_recommendations=5):
-    """Get pre-computed similar content from database"""
+# =============================================================================
+# DATA PROCESSING
+# =============================================================================
+def filter_content(content_list, filters):
+    """Apply filters to content list with error handling."""
     try:
-        # Get database credentials
-        api_token, _, content_endpoint, similarity_endpoints = get_api_credentials()
-        
-        if not api_token or not similarity_endpoints:
-            st.error("NocoDB credentials not configured properly.")
-            return []
-            
-        headers = {
-            "xc-token": api_token,
-            "accept": "application/json"
-        }
-        
-        title = content.get('title', '')
-        show_id = content.get('show_id', '')
-        
-        # Try finding by both show_id and title
-        query = f'where=(show_id,eq,{show_id})~and(title,eq,{title})'
-        params = {
-            "where": query
-        }
-        
-        for endpoint in similarity_endpoints:
-            if not endpoint.strip():  # Skip empty endpoints
-                continue
-                
-            try:
-                url = f"{NOCODB_URL.strip()}{endpoint.strip()}"
-                response = requests.get(url, headers=headers, params=params)
-                
-                if response.status_code == 200:
-                    data = response.json()
-                    if data.get('list'):
-                        for entry in data['list']:
-                            try:
-                                similar_items = json.loads(entry['similar_items'])
-                                
-                                # Get full content details for each similar item
-                                similar_content = []
-                                for item in similar_items[:n_recommendations]:
-                                    show_id = item.get('show_id', '')
-                                    query = f'where=(show_id,eq,{show_id})'
-                                    content_params = {
-                                        "where": query
-                                    }
-                                    content_url = f"{NOCODB_URL.strip()}{content_endpoint.strip()}"
-                                    content_response = requests.get(content_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)
-                                
-                                return similar_content[:n_recommendations]
-                            except Exception as parse_error:
-                                continue
-            except Exception as e:
-                continue
-        
-        return []
+        return [
+            content for content in content_list
+            if all([
+                content.get('streaming_service') in filters['streaming_services'],
+                (not filters['content_type'] or content.get('type') == filters['content_type']),
+                (not filters['genres'] or all(g.strip().lower() in str(content.get('listed_in', '')).lower() for g in filters['genres'])),
+                (not filters['ratings'] or content.get('rating', '').strip() in filters['ratings']),
+                filters['year_range'][0] <= int(content.get('release_year', 0)) <= filters['year_range'][1],
+                (not filters['director'] or any(name.strip().lower() in str(content.get('director', '')).lower() for name in filters['director'].split(','))),
+                (not filters['cast'] or any(name.strip().lower() in str(content.get('cast', '')).lower() for name in filters['cast'].split(',')))
+            ])
+        ]
     except Exception as e:
+        st.error(f"Error filtering content: {str(e)}")
         return []
 
-# =============================================================================
-# MAIN APP
-# =============================================================================
-def main():
-    # Page config
-    st.set_page_config(
-        page_title="StreamButler - Your Personal Streaming Concierge",
-        page_icon="🎩",
-        layout="wide"
-    )
-    
-    # Header with butler theme
-    st.title("🎩 StreamButler")
-    st.write("*At your service! Allow me to curate the perfect streaming entertainment for you.*")
-    
-    # Check API credentials
-    api_token, together_key, content_endpoint, similarity_endpoints = 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()
+def create_content_context(content_list):
+    """Create context string about current content."""
+    if not content_list:
+        return "No content matches the current filters."
     
-    if not api_token or not content_endpoint:
-        st.error("⚠️ NocoDB credentials not configured!")
-        st.info("Please set NOCODB_API_TOKEN and NOCODB_CONTENT_ENDPOINT in the Hugging Face Spaces secrets.")
-        st.stop()
+    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')
     
-    # 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()
+    genres = pd.Series([
+        g.strip() 
+        for c in content_list[:20] 
+        for g in str(c.get('listed_in', '')).split(',')
+    ]).value_counts()
     
-    # Load all content first
-    with st.spinner("Loading streaming content..."):
-        all_content = get_streaming_content()
+    context = f"""Currently showing {total} titles ({movies} movies and {shows} TV shows). """
+    if not genres.empty:
+        context += f"Popular genres include: {', '.join(genres.head(5).index)}. "
     
-    if not all_content:
-        st.error("Could not load streaming content. Please check your NocoDB connection.")
-        st.stop()
+    return context
+
+# =============================================================================
+# UI COMPONENTS
+# =============================================================================
+def render_filters_sidebar(all_content):
+    """Render the filters sidebar."""
+    st.sidebar.header("🔍 Filter Content")
     
-    # Extract unique values for filters
+    # Extract filter options
     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
+        if c and isinstance(c.get('rating'), str) 
+        and not c.get('rating').endswith('min')
+        and c.get('rating').strip()
     )))
+    
     all_genres = sorted(list(set(
         genre.strip()
         for c in all_content
-        for genre in c.get('listed_in', '').split(',')
+        for genre in str(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')])))
+    
+    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')
+    all_directors = sorted(list(set(
+        name.strip()
+        for c in all_content
+        for name in str(c.get('director', '')).split(',')
+        if name.strip()
+    )))
+    
+    all_cast_members = sorted(list(set(
+        name.strip()
+        for c in all_content
+        for name in str(c.get('cast', '')).split(',')
+        if name.strip()
+    )))
     
-    # Sidebar filters
-    st.sidebar.header("🔍 Filter Content")
-
     with st.sidebar.form("filter_form"):
+        # Streaming Services
         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
+            default=all_streaming_services[:1],
             help="Select the streaming services you have access to",
             key="streaming_services"
         )
@@ -407,31 +272,31 @@ def main():
         if not selected_services:
             st.warning("Please select at least one streaming service")
         
+        # Content Type
         st.subheader("Content Filters")
-        
         content_type = st.selectbox(
             "Content Type",
             options=["All", "Movie", "TV Show"],
             index=0
         )
         
+        # Genres
         selected_genres = st.multiselect(
             "Genres",
             options=all_genres,
             default=[]
         )
-
-        st.subheader("Optional Filters")
         
-        # Rating filter
+        # Optional Filters
+        st.subheader("Optional Filters")
         selected_ratings = st.multiselect(
             "Ratings",
             options=all_ratings,
             default=[],
             help="Filter by content rating"
         )
-
-        # Year range slider
+        
+        # Year range
         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(
@@ -442,13 +307,14 @@ def main():
             help="Filter by release year range"
         )
         
-        # Duration range slider (for movies only)
+        # Duration range for movies
         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', ''))
         ]
         
+        duration_range = (0, 1000)
         if movie_durations:
             min_duration = min(d for d in movie_durations if d > 0)
             max_duration = max(movie_durations)
@@ -459,10 +325,8 @@ def main():
                 value=(min_duration, max_duration),
                 help="This filter only applies to movies"
             )
-        else:
-            duration_range = (0, 1000)  # Fallback values
-
-        # Director filter with autocomplete
+        
+        # Director and Cast filters
         selected_directors = st.multiselect(
             "Directors",
             options=all_directors,
@@ -470,8 +334,7 @@ def main():
             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,
@@ -480,285 +343,294 @@ def main():
             placeholder="Start typing to search cast members..."
         )
         
-        # Submit button
         apply_filters = st.form_submit_button("🔍 Apply Filters", type="primary")
+        
+        return {
+            '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 '',
+            'apply_filters': apply_filters
+        }
+
+def render_content_list(filtered_content, page, items_per_page=10):
+    """Render the content list with pagination."""
+    if not filtered_content:
+        st.subheader("📋 No Titles Found")
+        return
     
-    # 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 ''
-    }
+    filtered_count = len(filtered_content)
+    st.subheader(f"📋 Found {filtered_count:,} Title{'s' if filtered_count != 1 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])
+    # Calculate page info
+    total_pages = (filtered_count + items_per_page - 1) // items_per_page
+    start_idx = (page - 1) * items_per_page
+    end_idx = min(start_idx + items_per_page, filtered_count)
     
-    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.container():
-                    st.write(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, n_recommendations=5)
-                            
-                            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[:5]:  # Show top 5 similar items
-                                        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')}")
-                                                st.write(f"*Cast:* {sim_content.get('cast')}")
-                                                st.write(f"*Director:* {sim_content.get('director')}")
-                                                st.write(f"*Description:* {sim_content.get('description')}")
-                                            with col2:
-                                                st.write(f"**Match:** {sim_content.get('similarity', 'N/A')}")
-                                            st.write("---")
-                                
-                                with sim_tab2:
-                                    st.write("**Why these recommendations?**")
-                                    st.write("""
-                                    These recommendations are based on multiple factors:
-                                    - 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.")
-                    st.write("---")
+    st.write(f"Showing {start_idx + 1}-{end_idx} of {filtered_count:,} titles")
+    
+    # Display content items
+    for i, content in enumerate(filtered_content[start_idx:end_idx], start=start_idx):
+        with st.container():
+            st.write(f"### {content.get('title', 'N/A')} ({content.get('release_year', 'N/A')})")
             
-            # Bottom pagination controls with better layout
-            st.write("---")
-            page_cols = st.columns([1, 2, 1, 2, 1])
+            detail_col1, detail_col2 = st.columns(2)
             
-            # 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()
+            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')}")
             
-            # Spacer
-            with page_cols[1]:
-                st.write("")
+            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')}")
             
-            # 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()
+            st.write(f"**📖 Description:**")
+            st.write(content.get('description', 'N/A'))
             
-            # Spacer
-            with page_cols[3]:
-                st.write("")
+            render_similar_content_section(content)
+            st.write("---")
+    
+    render_pagination_controls(page, total_pages)
+
+def render_similar_content_section(content):
+    """Render the similar content section for a content item."""
+    similar_button = st.button(f"🔍 Find Similar Content", key=f"similar_{content.get('show_id')}")
+    if similar_button:
+        with st.spinner("Finding similar content..."):
+            similar_content = get_similar_content(content, n_recommendations=5)
             
-            # 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.")
+            if similar_content:
+                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')}")
+                                st.write(f"*Cast:* {sim_content.get('cast')}")
+                                st.write(f"*Director:* {sim_content.get('director')}")
+                                st.write(f"*Description:* {sim_content.get('description')}")
+                            with col2:
+                                st.write(f"**Match:** {sim_content.get('similarity', 'N/A')}")
+                            st.write("---")
+                
+                with sim_tab2:
+                    st.write("**Why these recommendations?**")
+                    st.write("""
+                    These recommendations are based on multiple factors:
+                    - 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.")
+
+def render_pagination_controls(current_page, total_pages):
+    """Render pagination controls."""
+    st.write("---")
+    page_cols = st.columns([1, 2, 1, 2, 1])
     
-    with col2:
-        # AI Chat Section
-        st.subheader("🎩 Your Personal Butler")
-        st.write("How may I be of assistance in finding your perfect entertainment today?")
-        
-        # Model selection for Together AI
-        model_choice = st.selectbox(
-            "Select Your Butler's Expertise Level:",
-            [
-                "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 your butler's level of expertise in making recommendations"
-        )
-        
-        # Example questions
-        with st.expander("💡 How to Address Your Butler"):
-            st.write("""
-            Your butler understands requests like:
-            • "My good sir, I seek an action film that would also please my companion who favors comedies."
-            • "Would you be so kind as to suggest a family-friendly show in the spirit of Stranger Things, but less frightening?"
-            • "I've quite enjoyed The Crown and Downton Abbey. Might you recommend similar period dramas?"
-            • "The weather is rather gloomy today. Perhaps a charming romantic comedy or musical?"
-            • "I'm in search of enlightening documentaries about technology or artificial intelligence."
-            • "We're hosting a gathering this evening. What entertainment would you suggest for a group?"
-            """)
-        
-        user_question = st.text_area(
-            "How May I Assist You?",
-            placeholder="Tell me your preferences, and I shall curate the perfect selection...",
-            height=100
+    with page_cols[0]:
+        if st.button("← Previous", disabled=current_page == 1, use_container_width=True):
+            st.session_state.current_page = max(1, current_page - 1)
+            st.rerun()
+    
+    with page_cols[2]:
+        page_input = st.number_input(
+            f"Page (of {total_pages})",
+            min_value=1,
+            max_value=total_pages,
+            value=current_page,
+            key="page_number",
+            help=f"Enter a page number between 1 and {total_pages}"
         )
-        
-        if st.button("🎩 Request Recommendations", type="primary"):
-            if user_question:
-                with st.spinner("Your butler is carefully selecting the perfect entertainment..."):
-                    # Create context from current filtered data
-                    context = create_content_context(st.session_state.filtered_content)
+        if page_input != current_page:
+            st.session_state.current_page = page_input
+            st.rerun()
+    
+    with page_cols[4]:
+        if st.button("Next →", disabled=current_page == total_pages, use_container_width=True):
+            st.session_state.current_page = min(total_pages, current_page + 1)
+            st.rerun()
+
+def render_ai_chat_section(client, filtered_content):
+    """Render the AI chat section."""
+    st.subheader("🎩 Your Personal Butler")
+    st.write("How may I be of assistance in finding your perfect entertainment today?")
+    
+    model_choice = st.selectbox(
+        "Select Your Butler's Expertise Level:",
+        [
+            "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 your butler's level of expertise in making recommendations"
+    )
+    
+    with st.expander("💡 How to Address Your Butler"):
+        st.write("""
+        Your butler understands requests like:
+        • "My good sir, I seek an action film that would also please my companion who favors comedies."
+        • "Would you be so kind as to suggest a family-friendly show in the spirit of Stranger Things, but less frightening?"
+        • "I've quite enjoyed The Crown and Downton Abbey. Might you recommend similar period dramas?"
+        • "The weather is rather gloomy today. Perhaps a charming romantic comedy or musical?"
+        • "I'm in search of enlightening documentaries about technology or artificial intelligence."
+        • "We're hosting a gathering this evening. What entertainment would you suggest for a group?"
+        """)
+    
+    user_question = st.text_area(
+        "How May I Assist You?",
+        placeholder="Tell me your preferences, and I shall curate the perfect selection...",
+        height=100
+    )
+    
+    if st.button("🎩 Request Recommendations", type="primary"):
+        if user_question:
+            with st.spinner("Your butler is carefully selecting the perfect entertainment..."):
+                context = create_content_context(filtered_content)
+                try:
+                    ai_response = get_ai_response(client, user_question, context, model_choice)
+                    st.success("**🎩 Your Curated Selection:**")
+                    st.write(ai_response)
                     
-                    try:
-                        # Get AI response
-                        ai_response = get_ai_response(client, user_question, context, model_choice)
-                        
-                        st.success("**🎩 Your Curated Selection:**")
-                        st.write(ai_response)
-                        
-                        # Show streaming availability
-                        with st.expander("🎩 Butler's Note"):
-                            st.write("""
-                            To access your selected entertainment:
-                            1. Kindly select your preferred streaming services above
-                            2. Locate your chosen title in the curated list
-                            3. For similar recommendations, simply request "Find Similar Content"
-                            
-                            *Is there anything else I can assist you with?*
-                            """)
-                        
-                    except Exception as e:
-                        st.error("My sincerest apologies, but I seem to be unable to process your request at the moment. Might we try again?")
+                    with st.expander("🎩 Butler's Note"):
+                        st.write("""
+                        To access your selected entertainment:
+                        1. Kindly select your preferred streaming services above
+                        2. Locate your chosen title in the curated list
+                        3. For similar recommendations, simply request "Find Similar Content"
                         
-            else:
-                st.warning("How may I be of assistance? Please share your entertainment preferences.")
-    
-    # Footer stats with butler theme
+                        *Is there anything else I can assist you with?*
+                        """)
+                except Exception as e:
+                    st.error("My sincerest apologies, but I seem to be unable to process your request at the moment. Might we try again?")
+        else:
+            st.warning("How may I be of assistance? Please share your entertainment preferences.")
+
+def render_footer_stats(all_content, filtered_content, selected_services):
+    """Render footer statistics."""
     st.markdown("---")
-    if all_content:
-        total_items = len(all_content)
-        filtered_items = len(st.session_state.filtered_content)
-        
-        st.markdown("### 🎩 Your Entertainment Library")
-        
-        # 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("📚 Complete Collection", f"{total_items:,}")
-        
-        with stat_cols[1]:
-            st.metric("🎯 Curated Selection", 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("🎬 Films / 📺 Series", f"{movies:,} / {shows:,}")
-        
-        # Streaming service breakdown with icons
-        service_icons = {
-            "Netflix": "🔴",
-            "Amazon Prime": "🔵",
-            "Hulu": "🟢",
-            "Disney+": "🟣"
-        }
+    if not all_content:
+        return
         
-        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:,}")
+    total_items = len(all_content)
+    filtered_items = len(filtered_content)
+    
+    st.markdown("### 🎩 Your Entertainment Library")
+    
+    stat_cols = st.columns(len(selected_services) + 3)
+    
+    with stat_cols[0]:
+        st.metric("📚 Complete Collection", f"{total_items:,}")
+    
+    with stat_cols[1]:
+        st.metric("🎯 Curated Selection", f"{filtered_items:,}")
+    
+    with stat_cols[2]:
+        movies = sum(1 for c in filtered_content if c.get('type') == 'Movie')
+        shows = sum(1 for c in filtered_content if c.get('type') == 'TV Show')
+        st.metric("🎬 Films / 📺 Series", f"{movies:,} / {shows:,}")
+    
+    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 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:,}")
+
+def main():
+    """Main application entry point."""
+    # Page config
+    st.set_page_config(
+        page_title="StreamButler - Your Personal Streaming Concierge",
+        page_icon="🎩",
+        layout="wide"
+    )
+    
+    # Header
+    st.title("🎩 StreamButler")
+    st.write("*At your service! Allow me to curate the perfect streaming entertainment for you.*")
+    
+    # Check API credentials
+    creds = get_api_credentials()
+    if not creds['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 creds['api_token'] or not creds['content_endpoint']:
+        st.error("⚠️ NocoDB credentials not configured!")
+        st.info("Please set NOCODB_API_TOKEN and NOCODB_CONTENT_ENDPOINT 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 content
+    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()
+    
+    # Render filters sidebar
+    filters = render_filters_sidebar(all_content)
+    
+    # Apply filters
+    if filters['apply_filters']:
+        filtered_content = filter_content(all_content, filters)
+        st.session_state.filtered_content = filtered_content
+    else:
+        if 'filtered_content' not in st.session_state:
+            st.session_state.filtered_content = all_content
+    
+    # Initialize page number
+    if 'current_page' not in st.session_state:
+        st.session_state.current_page = 1
+    
+    # Main content layout
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        render_content_list(st.session_state.filtered_content, st.session_state.current_page)
+    
+    with col2:
+        render_ai_chat_section(client, st.session_state.filtered_content)
+    
+    # Footer stats
+    render_footer_stats(all_content, st.session_state.filtered_content, filters['streaming_services'])
 
 if __name__ == "__main__":
     main()