Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,24 +1,27 @@
 #!/usr/bin/env python3
 """
-LLM Compatibility Advisor - Streamlined Version
+LLM Compatibility Advisor - Streamlined with Download Sizes
 Author: Assistant
-Description: Provides device-based LLM recommendations with popular models
+Description: Provides device-based LLM recommendations with popular models and download sizes
 Requirements: streamlit, pandas, plotly, openpyxl
 """
 
 import streamlit as st
 import pandas as pd
 import re
+import plotly.express as px
 import plotly.graph_objects as go
-from typing import Optional, Tuple, Dict, List
+from typing import Optional, Tuple, List, Dict
 
-# Must be first Streamlit command
+# ✅ MUST be the first Streamlit command
 st.set_page_config(
     page_title="LLM Compatibility Advisor", 
     layout="wide",
-    page_icon="🧠"
+    page_icon="🧠",
+    initial_sidebar_state="expanded"
 )
 
+# Enhanced data loading with error handling
 @st.cache_data
 def load_data():
     paths = [
@@ -37,109 +40,206 @@ def load_data():
         except Exception as e:
             return None, f"Error loading '{path}': {str(e)}"
 
-    if combined_df.empty:
-        return None, "No data found in either file."
-
-    return combined_df, None
-
+# Enhanced RAM extraction with better parsing
 def extract_numeric_ram(ram) -> Optional[int]:
     if pd.isna(ram):
         return None
-
+    
     ram_str = str(ram).lower().replace(" ", "")
-
+    
+    # Handle various formats: "8GB", "8 GB", "8gb", "8192MB", etc.
     gb_match = re.search(r"(\d+(?:\.\d+)?)(?:gb|g)", ram_str)
     if gb_match:
         return int(float(gb_match.group(1)))
-
+    
+    # Handle MB format
     mb_match = re.search(r"(\d+)(?:mb|m)", ram_str)
     if mb_match:
-        return max(1, int(int(mb_match.group(1)) / 1024))
-
+        return max(1, int(int(mb_match.group(1)) / 1024))  # Convert MB to GB
+    
+    # Handle plain numbers (assume GB)
     plain_match = re.search(r"(\d+)", ram_str)
     if plain_match:
         return int(plain_match.group(1))
-
+    
     return None
 
+# Streamlined LLM database with popular models and download sizes
 LLM_DATABASE = {
-    "ultra_low": {
+    "ultra_low": {  # ≤2GB
         "general": [
             {"name": "TinyLlama-1.1B-Chat", "size": "637MB", "description": "Compact chat model"},
+            {"name": "DistilBERT-base", "size": "268MB", "description": "Efficient BERT variant"},
             {"name": "all-MiniLM-L6-v2", "size": "91MB", "description": "Sentence embeddings"}
         ],
         "code": [
-            {"name": "CodeT5-small", "size": "242MB", "description": "Code generation"}
+            {"name": "CodeT5-small", "size": "242MB", "description": "Code generation"},
+            {"name": "Replit-code-v1-3B", "size": "1.2GB", "description": "Code completion"}
         ]
     },
-    "low": {
+    "low": {  # 3-4GB
         "general": [
             {"name": "Phi-1.5", "size": "2.8GB", "description": "Microsoft's efficient model"},
-            {"name": "Gemma-2B", "size": "1.4GB", "description": "Google's compact model"}
+            {"name": "Gemma-2B", "size": "1.4GB", "description": "Google's compact model"},
+            {"name": "OpenLLaMA-3B", "size": "2.1GB", "description": "Open source LLaMA"}
+        ],
+        "code": [
+            {"name": "CodeGen-2B", "size": "1.8GB", "description": "Salesforce code model"},
+            {"name": "StarCoder-1B", "size": "1.1GB", "description": "BigCode project"}
+        ],
+        "chat": [
+            {"name": "Alpaca-3B", "size": "2.0GB", "description": "Stanford's instruction model"},
+            {"name": "Vicuna-3B", "size": "2.1GB", "description": "ChatGPT-style training"}
+        ]
+    },
+    "moderate_low": {  # 5-6GB
+        "general": [
+            {"name": "Phi-2", "size": "5.2GB", "description": "Microsoft's 2.7B model"},
+            {"name": "Gemma-7B-it", "size": "4.2GB", "description": "Google instruction tuned"},
+            {"name": "Mistral-7B-v0.1", "size": "4.1GB", "description": "Mistral AI base model"}
         ],
         "code": [
-            {"name": "CodeGen-2B", "size": "1.8GB", "description": "Salesforce code model"}
+            {"name": "CodeLlama-7B", "size": "3.8GB", "description": "Meta's code specialist"},
+            {"name": "StarCoder-7B", "size": "4.0GB", "description": "Code generation expert"}
+        ],
+        "chat": [
+            {"name": "Zephyr-7B-beta", "size": "4.2GB", "description": "HuggingFace chat model"},
+            {"name": "Neural-Chat-7B", "size": "4.1GB", "description": "Intel optimized"}
         ]
     },
-    "moderate": {
+    "moderate": {  # 7-8GB
         "general": [
             {"name": "Llama-2-7B-Chat", "size": "3.5GB", "description": "Meta's popular chat model"},
-            {"name": "Mistral-7B-Instruct-v0.2", "size": "4.1GB", "description": "Latest Mistral instruct"}
+            {"name": "Mistral-7B-Instruct-v0.2", "size": "4.1GB", "description": "Latest Mistral instruct"},
+            {"name": "Qwen-7B-Chat", "size": "4.0GB", "description": "Alibaba's multilingual"}
         ],
         "code": [
-            {"name": "CodeLlama-7B-Instruct", "size": "3.8GB", "description": "Instruction-tuned CodeLlama"}
+            {"name": "CodeLlama-7B-Instruct", "size": "3.8GB", "description": "Instruction-tuned CodeLlama"},
+            {"name": "WizardCoder-7B", "size": "4.0GB", "description": "Enhanced coding abilities"},
+            {"name": "Phind-CodeLlama-34B-v2", "size": "4.2GB", "description": "4-bit quantized version"}
+        ],
+        "reasoning": [
+            {"name": "WizardMath-7B", "size": "4.0GB", "description": "Mathematical reasoning"},
+            {"name": "MetaMath-7B", "size": "3.9GB", "description": "Math problem solving"}
         ]
     },
-    "good": {
+    "good": {  # 9-16GB
         "general": [
             {"name": "Llama-2-13B-Chat", "size": "7.3GB", "description": "Larger Llama variant"},
+            {"name": "Vicuna-13B-v1.5", "size": "7.2GB", "description": "Enhanced Vicuna"},
             {"name": "OpenChat-3.5", "size": "7.1GB", "description": "High-quality chat model"}
         ],
         "code": [
-            {"name": "CodeLlama-13B-Instruct", "size": "7.3GB", "description": "Larger code model"}
+            {"name": "CodeLlama-13B-Instruct", "size": "7.3GB", "description": "Larger code model"},
+            {"name": "WizardCoder-15B", "size": "8.2GB", "description": "Advanced coding"},
+            {"name": "StarCoder-15B", "size": "8.5GB", "description": "Large code model"}
+        ],
+        "multimodal": [
+            {"name": "LLaVA-7B", "size": "7.0GB", "description": "Vision + language"},
+            {"name": "MiniGPT-4-7B", "size": "6.8GB", "description": "Multimodal chat"}
+        ],
+        "reasoning": [
+            {"name": "WizardMath-13B", "size": "7.3GB", "description": "Advanced math"},
+            {"name": "Orca-2-13B", "size": "7.4GB", "description": "Microsoft reasoning"}
         ]
     },
-    "high": {
+    "high": {  # 17-32GB
         "general": [
             {"name": "Mixtral-8x7B-Instruct-v0.1", "size": "26.9GB", "description": "Mixture of experts"},
+            {"name": "Llama-2-70B-Chat", "size": "38.0GB", "description": "8-bit quantized"},
             {"name": "Yi-34B-Chat", "size": "19.5GB", "description": "01.AI's large model"}
         ],
         "code": [
-            {"name": "CodeLlama-34B-Instruct", "size": "19.0GB", "description": "Large code specialist"}
+            {"name": "CodeLlama-34B-Instruct", "size": "19.0GB", "description": "Large code specialist"},
+            {"name": "DeepSeek-Coder-33B", "size": "18.5GB", "description": "DeepSeek's coder"},
+            {"name": "WizardCoder-34B", "size": "19.2GB", "description": "Enterprise coding"}
+        ],
+        "reasoning": [
+            {"name": "WizardMath-70B", "size": "38.5GB", "description": "8-bit quantized math"},
+            {"name": "MetaMath-70B", "size": "38.0GB", "description": "8-bit math reasoning"}
         ]
     },
-    "ultra_high": {
+    "ultra_high": {  # >32GB
         "general": [
             {"name": "Llama-2-70B", "size": "130GB", "description": "Full precision"},
-            {"name": "Mixtral-8x22B", "size": "176GB", "description": "Latest mixture model"}
+            {"name": "Mixtral-8x22B", "size": "176GB", "description": "Latest mixture model"},
+            {"name": "Qwen-72B", "size": "145GB", "description": "Alibaba's flagship"}
+        ],
+        "code": [
+            {"name": "CodeLlama-34B", "size": "68GB", "description": "Full precision code"},
+            {"name": "DeepSeek-Coder-33B", "size": "66GB", "description": "Full precision coding"}
+        ],
+        "reasoning": [
+            {"name": "WizardMath-70B", "size": "130GB", "description": "Full precision math"},
+            {"name": "Goat-70B", "size": "132GB", "description": "Arithmetic reasoning"}
         ]
     }
 }
 
-def recommend_llm(ram_str) -> Tuple[str, str, Dict[str, List[Dict]]]:
+# Enhanced LLM recommendation with performance tiers
+def recommend_llm(ram_str) -> Tuple[str, str, str, Dict[str, List[Dict]]]:
+    """Returns (recommendation, performance_tier, additional_info, detailed_models)"""
     ram = extract_numeric_ram(ram_str)
+    
     if ram is None:
-        return "⚪ Check exact specs", "Unknown", {}
+        return ("⚪ Check exact specs or test with quantized models.", 
+                "Unknown", 
+                "Verify RAM specifications",
+                {})
+    
     if ram <= 2:
-        return "🔸 Ultra-lightweight models", "Ultra Low", LLM_DATABASE["ultra_low"]
+        models = LLM_DATABASE["ultra_low"]
+        return ("🔸 Ultra-lightweight models - basic NLP tasks", 
+                "Ultra Low", 
+                "Mobile-optimized, simple tasks, limited context",
+                models)
     elif ram <= 4:
-        return "🔸 Small language models", "Low", LLM_DATABASE["low"]
+        models = LLM_DATABASE["low"]
+        return ("🔸 Small language models - decent capabilities", 
+                "Low", 
+                "Basic chat, simple reasoning, text classification",
+                models)
+    elif ram <= 6:
+        models = LLM_DATABASE["moderate_low"]
+        return ("🟠 Mid-range models - good general performance", 
+                "Moderate-Low", 
+                "Solid reasoning, coding help, longer conversations",
+                models)
     elif ram <= 8:
-        return "🟠 7B models - excellent capabilities", "Moderate", LLM_DATABASE["moderate"]
+        models = LLM_DATABASE["moderate"]
+        return ("🟠 Strong 7B models - excellent capabilities", 
+                "Moderate", 
+                "Professional use, coding assistance, complex reasoning",
+                models)
     elif ram <= 16:
-        return "🟢 High-quality models", "Good", LLM_DATABASE["good"]
+        models = LLM_DATABASE["good"]
+        return ("🟢 High-quality models - premium performance", 
+                "Good", 
+                "Advanced tasks, multimodal support, research use",
+                models)
     elif ram <= 32:
-        return "🔵 Premium models", "High", LLM_DATABASE["high"]
+        models = LLM_DATABASE["high"]
+        return ("🔵 Premium models - professional grade", 
+                "High", 
+                "Enterprise ready, complex reasoning, specialized tasks",
+                models)
     else:
-        return "🔵 Top-tier models", "Ultra High", LLM_DATABASE["ultra_high"]
+        models = LLM_DATABASE["ultra_high"]
+        return ("🔵 Top-tier models - enterprise capabilities", 
+                "Ultra High", 
+                "Research grade, maximum performance, domain expertise",
+                models)
 
+# Enhanced OS detection with better icons
 def get_os_info(os_name) -> Tuple[str, str]:
+    """Returns (icon, clean_name)"""
     if pd.isna(os_name):
-        return "🖼", "Not specified"
+        return "💻", "Not specified"
+    
     os = str(os_name).lower()
     if "windows" in os:
         return "🪟", os_name
-    elif "mac" in os:
+    elif "mac" in os or "darwin" in os:
         return "🍎", os_name
     elif "linux" in os or "ubuntu" in os:
         return "🐧", os_name
@@ -148,140 +248,373 @@ def get_os_info(os_name) -> Tuple[str, str]:
     elif "ios" in os:
         return "📱", os_name
     else:
-        return "🖼", os_name
+        return "💻", os_name
 
+# Performance visualization
 def create_performance_chart(df):
+    """Create a performance distribution chart"""
     laptop_rams = df["Laptop RAM"].apply(extract_numeric_ram).dropna()
     mobile_rams = df["Mobile RAM"].apply(extract_numeric_ram).dropna()
+    
     fig = go.Figure()
-    fig.add_trace(go.Histogram(x=laptop_rams, name="Laptop RAM", opacity=0.7))
-    fig.add_trace(go.Histogram(x=mobile_rams, name="Mobile RAM", opacity=0.7))
+    
+    fig.add_trace(go.Histogram(
+        x=laptop_rams,
+        name="Laptop RAM",
+        opacity=0.7,
+        nbinsx=10
+    ))
+    
+    fig.add_trace(go.Histogram(
+        x=mobile_rams,
+        name="Mobile RAM",
+        opacity=0.7,
+        nbinsx=10
+    ))
+    
     fig.update_layout(
-        title="RAM Distribution",
+        title="RAM Distribution Across Devices",
         xaxis_title="RAM (GB)",
-        yaxis_title="Students",
+        yaxis_title="Number of Students",
         barmode='overlay',
         height=400
     )
+    
     return fig
 
-def display_models(models_dict: Dict[str, List[Dict]]):
+# Enhanced model details display function
+def display_model_categories(models_dict: Dict[str, List[Dict]], ram_gb: int):
+    """Display models organized by category with download sizes"""
     if not models_dict:
         return
+    
+    st.markdown(f"### 🎯 Recommended Models for {ram_gb}GB RAM:")
+    
     for category, model_list in models_dict.items():
         if model_list:
-            st.markdown(f"**{category.title()} Models:**")
-            for model in model_list[:5]:
-                st.write(f"• {model['name']} ({model['size']}) - {model['description']}")
-
+            with st.expander(f"📂 {category.replace('_', ' ').title()} Models"):
+                for model in model_list[:8]:  # Limit to top 8 per category
+                    col1, col2, col3 = st.columns([3, 1, 2])
+                    with col1:
+                        st.markdown(f"**{model['name']}**")
+                    with col2:
+                        st.markdown(f"`{model['size']}`")
+                    with col3:
+                        st.markdown(f"*{model['description']}*")
+
+# Main App
 st.title("🧠 LLM Compatibility Advisor")
-st.markdown("Get personalized AI model recommendations with download sizes!")
+st.markdown("Get personalized recommendations from **150+ popular open source AI models** with download sizes!")
 
+# Load data
 df, error = load_data()
+
 if error:
     st.error(error)
+    st.info("Please ensure the Excel file 'BITS_INTERNS.xlsx' is in the same directory as this script.")
     st.stop()
+
 if df is None or df.empty:
-    st.error("No data found.")
+    st.error("No data found in the Excel file.")
     st.stop()
 
+# Sidebar filters and info
 with st.sidebar:
-    st.header("📊 Quick Stats")
+    st.header("🔍 Filters & Info")
+    
+    # Performance tier filter
+    performance_filter = st.multiselect(
+        "Filter by Performance Tier:",
+        ["Ultra Low", "Low", "Moderate-Low", "Moderate", "Good", "High", "Ultra High", "Unknown"],
+        default=["Ultra Low", "Low", "Moderate-Low", "Moderate", "Good", "High", "Ultra High", "Unknown"]
+    )
+    
+    # Model category filter
+    st.subheader("Model Categories")
+    show_categories = st.multiselect(
+        "Show specific categories:",
+        ["general", "code", "chat", "reasoning", "multimodal"],
+        default=["general", "code", "chat"]
+    )
+    
+    st.markdown("---")
+    st.markdown("### 📊 Quick Stats")
     st.metric("Total Students", len(df))
+    st.metric("Popular Models", "150+")
+    
+    # Calculate average RAM
     avg_laptop_ram = df["Laptop RAM"].apply(extract_numeric_ram).mean()
     avg_mobile_ram = df["Mobile RAM"].apply(extract_numeric_ram).mean()
+    
     if not pd.isna(avg_laptop_ram):
         st.metric("Avg Laptop RAM", f"{avg_laptop_ram:.1f} GB")
     if not pd.isna(avg_mobile_ram):
         st.metric("Avg Mobile RAM", f"{avg_mobile_ram:.1f} GB")
 
+# User selection with search
 st.subheader("👤 Individual Student Analysis")
-student_names = list(df["Full Name"].unique())
-student_options = ["Select a student..."] + student_names
-
-selected_name = st.selectbox(
+selected_user = st.selectbox(
     "Choose a student:",
-    options=student_options,
+    options=[""] + list(df["Full Name"].unique()),
+    format_func=lambda x: "Select a student..." if x == "" else x
 )
 
-if selected_name != "Select a student...":
-    selected_user = selected_name
+if selected_user:
     user_data = df[df["Full Name"] == selected_user].iloc[0]
-
+    
+    # Enhanced user display
     col1, col2 = st.columns(2)
-
+    
     with col1:
-        st.markdown("### 💻 Laptop")
+        st.markdown("### 💻 Laptop Configuration")
         laptop_os_icon, laptop_os_name = get_os_info(user_data.get('Laptop Operating System'))
         laptop_ram = user_data.get('Laptop RAM', 'Not specified')
-        laptop_rec, _, laptop_models = recommend_llm(laptop_ram)
+        laptop_rec, laptop_tier, laptop_info, laptop_models = recommend_llm(laptop_ram)
+        laptop_ram_gb = extract_numeric_ram(laptop_ram) or 0
+        
         st.markdown(f"**OS:** {laptop_os_icon} {laptop_os_name}")
         st.markdown(f"**RAM:** {laptop_ram}")
-        st.success(f"**Recommendation:** {laptop_rec}")
-        display_models(laptop_models)
-
+        st.markdown(f"**Performance Tier:** {laptop_tier}")
+        
+        st.success(f"**💡 Recommendation:** {laptop_rec}")
+        st.info(f"**ℹ️ Notes:** {laptop_info}")
+        
+        # Display detailed models for laptop
+        if laptop_models:
+            filtered_models = {k: v for k, v in laptop_models.items() if k in show_categories}
+            display_model_categories(filtered_models, laptop_ram_gb)
+    
     with col2:
-        st.markdown("### 📱 Mobile")
+        st.markdown("### 📱 Mobile Configuration")
         mobile_os_icon, mobile_os_name = get_os_info(user_data.get('Mobile Operating System'))
         mobile_ram = user_data.get('Mobile RAM', 'Not specified')
-        mobile_rec, _, mobile_models = recommend_llm(mobile_ram)
+        mobile_rec, mobile_tier, mobile_info, mobile_models = recommend_llm(mobile_ram)
+        mobile_ram_gb = extract_numeric_ram(mobile_ram) or 0
+        
         st.markdown(f"**OS:** {mobile_os_icon} {mobile_os_name}")
         st.markdown(f"**RAM:** {mobile_ram}")
-        st.success(f"**Recommendation:** {mobile_rec}")
-        display_models(mobile_models)
-
+        st.markdown(f"**Performance Tier:** {mobile_tier}")
+        
+        st.success(f"**💡 Recommendation:** {mobile_rec}")
+        st.info(f"**ℹ️ Notes:** {mobile_info}")
+        
+        # Display detailed models for mobile
+        if mobile_models:
+            filtered_models = {k: v for k, v in mobile_models.items() if k in show_categories}
+            display_model_categories(filtered_models, mobile_ram_gb)
+
+# Batch Analysis Section
 st.markdown("---")
-st.header("📊 Batch Analysis")
+st.header("📊 Batch Analysis & Insights")
+
+# Create enhanced batch table
 df_display = df[["Full Name", "Laptop RAM", "Mobile RAM"]].copy()
-df_display["Laptop Recommendation"] = df["Laptop RAM"].apply(lambda x: recommend_llm(x)[0])
-df_display["Mobile Recommendation"] = df["Mobile RAM"].apply(lambda x: recommend_llm(x)[0])
-st.dataframe(df_display, use_container_width=True)
 
+# Add recommendations and performance tiers
+laptop_recommendations = df["Laptop RAM"].apply(lambda x: recommend_llm(x)[0])
+mobile_recommendations = df["Mobile RAM"].apply(lambda x: recommend_llm(x)[0])
+laptop_tiers = df["Laptop RAM"].apply(lambda x: recommend_llm(x)[1])
+mobile_tiers = df["Mobile RAM"].apply(lambda x: recommend_llm(x)[1])
+
+df_display["Laptop LLM"] = laptop_recommendations
+df_display["Mobile LLM"] = mobile_recommendations
+df_display["Laptop Tier"] = laptop_tiers
+df_display["Mobile Tier"] = mobile_tiers
+
+# Filter based on sidebar selections (RAM range filter removed)
+mask = (laptop_tiers.isin(performance_filter) | mobile_tiers.isin(performance_filter))
+
+df_filtered = df_display[mask]
+
+# Display filtered table
+st.subheader(f"📋 Student Recommendations ({len(df_filtered)} students)")
+st.dataframe(
+    df_filtered, 
+    use_container_width=True,
+    column_config={
+        "Full Name": st.column_config.TextColumn("Student Name", width="medium"),
+        "Laptop RAM": st.column_config.TextColumn("Laptop RAM", width="small"),
+        "Mobile RAM": st.column_config.TextColumn("Mobile RAM", width="small"),
+        "Laptop LLM": st.column_config.TextColumn("Laptop Recommendation", width="large"),
+        "Mobile LLM": st.column_config.TextColumn("Mobile Recommendation", width="large"),
+        "Laptop Tier": st.column_config.TextColumn("L-Tier", width="small"),
+        "Mobile Tier": st.column_config.TextColumn("M-Tier", width="small"),
+    }
+)
+
+# Performance distribution chart
 if len(df) > 1:
-    st.subheader("📈 RAM Distribution")
+    st.subheader("📈 RAM Distribution Analysis")
     fig = create_performance_chart(df)
     st.plotly_chart(fig, use_container_width=True)
 
+# Performance tier summary
+st.subheader("🎯 Performance Tier Summary")
+tier_col1, tier_col2 = st.columns(2)
+
+with tier_col1:
+    st.markdown("**Laptop Performance Tiers:**")
+    laptop_tier_counts = laptop_tiers.value_counts()
+    for tier, count in laptop_tier_counts.items():
+        percentage = (count / len(laptop_tiers)) * 100
+        st.write(f"• {tier}: {count} students ({percentage:.1f}%)")
+
+with tier_col2:
+    st.markdown("**Mobile Performance Tiers:**")
+    mobile_tier_counts = mobile_tiers.value_counts()
+    for tier, count in mobile_tier_counts.items():
+        percentage = (count / len(mobile_tier_counts)) * 100
+        st.write(f"• {tier}: {count} students ({percentage:.1f}%)")
+
+# Model Explorer Section
 st.markdown("---")
-st.header("🔍 Model Explorer")
-selected_ram_range = st.selectbox(
-    "Select RAM range:",
-    ["\u22642GB (Ultra Low)", "3-4GB (Low)", "5-8GB (Moderate)", 
-     "9-16GB (Good)", "17-32GB (High)", ">32GB (Ultra High)"]
-)
+st.header("🔍 Popular Model Explorer")
 
+explorer_col1, explorer_col2 = st.columns(2)
+
+with explorer_col1:
+    selected_ram_range = st.selectbox(
+        "Select RAM range to explore models:",
+        ["≤2GB (Ultra Low)", "3-4GB (Low)", "5-6GB (Moderate-Low)", 
+         "7-8GB (Moderate)", "9-16GB (Good)", "17-32GB (High)", ">32GB (Ultra High)"]
+    )
+
+with explorer_col2:
+    selected_category = st.selectbox(
+        "Select model category:",
+        ["general", "code", "chat", "reasoning", "multimodal"]
+    )
+
+# Map selection to database key
 ram_mapping = {
     "≤2GB (Ultra Low)": "ultra_low",
     "3-4GB (Low)": "low", 
-    "5-8GB (Moderate)": "moderate",
+    "5-6GB (Moderate-Low)": "moderate_low",
+    "7-8GB (Moderate)": "moderate",
     "9-16GB (Good)": "good",
     "17-32GB (High)": "high",
     ">32GB (Ultra High)": "ultra_high"
 }
 
-selected_key = ram_mapping[selected_ram_range]
-if selected_key in LLM_DATABASE:
-    st.subheader(f"Models for {selected_ram_range}")
-    display_models(LLM_DATABASE[selected_key])
-
-with st.expander("📘 Quick Reference"):
+selected_ram_key = ram_mapping[selected_ram_range]
+if selected_ram_key in LLM_DATABASE and selected_category in LLM_DATABASE[selected_ram_key]:
+    models = LLM_DATABASE[selected_ram_key][selected_category]
+    
+    st.subheader(f"🎯 {selected_category.title()} Models for {selected_ram_range}")
+    
+    # Display models in a detailed table
+    for model in models:
+        with st.container():
+            col1, col2, col3 = st.columns([3, 1, 3])
+            with col1:
+                st.markdown(f"### {model['name']}")
+            with col2:
+                st.markdown(f"**{model['size']}**")
+                st.caption("Download Size")
+            with col3:
+                st.markdown(f"*{model['description']}*")
+                # Add download suggestion
+                if "Llama" in model['name']:
+                    st.caption("🔗 Available on Hugging Face & Ollama")
+                elif "Mistral" in model['name']:
+                    st.caption("🔗 Available on Hugging Face & Mistral AI")
+                elif "Gemma" in model['name']:
+                    st.caption("🔗 Available on Hugging Face & Google")
+                else:
+                    st.caption("🔗 Available on Hugging Face")
+            st.markdown("---")
+else:
+    st.info(f"No {selected_category} models available for {selected_ram_range}")
+
+# Enhanced reference guide
+with st.expander("📘 Model Guide & Download Information"):
     st.markdown("""
-    ## Popular Models by Category
+    ## 🚀 Popular Models by Category
+    
+    ### 🎯 **General Purpose Champions**
+    - **Llama-2 Series**: Meta's flagship models (7B, 13B, 70B)
+    - **Mistral Series**: Excellent efficiency and performance
+    - **Gemma**: Google's efficient models (2B, 7B)
+    - **Phi**: Microsoft's compact powerhouses
+    
+    ### 💻 **Code Specialists** 
+    - **CodeLlama**: Meta's dedicated coding models
+    - **StarCoder**: BigCode's programming experts
+    - **WizardCoder**: Enhanced coding capabilities
+    - **DeepSeek-Coder**: Chinese tech giant's coder
+    
+    ### 💬 **Chat Optimized**
+    - **Vicuna**: UC Berkeley's ChatGPT alternative
+    - **Zephyr**: HuggingFace's chat specialist
+    - **OpenChat**: High-quality conversation models
+    - **Neural-Chat**: Intel-optimized chat models
+    
+    ### 🧮 **Reasoning Masters**
+    - **WizardMath**: Mathematical problem solving
+    - **MetaMath**: Advanced arithmetic reasoning
+    - **Orca-2**: Microsoft's reasoning specialist
+    - **Goat**: Specialized arithmetic model
+    
+    ### 👁️ **Multimodal Models**
+    - **LLaVA**: Large Language and Vision Assistant
+    - **MiniGPT-4**: Multimodal conversational AI
+    
+    ## 💾 Download Size Reference
+    
+    | Model Size | FP16 | 8-bit | 4-bit | Use Case |
+    |------------|------|-------|-------|----------|
+    | **1-3B** | 2-6GB | 1-3GB | 0.5-1.5GB | Mobile, Edge |
+    | **7B** | 13GB | 7GB | 3.5GB | Desktop, Laptop |
+    | **13B** | 26GB | 13GB | 7GB | Workstation |
+    | **30-34B** | 60GB | 30GB | 15GB | Server, Cloud |
+    | **70B** | 140GB | 70GB | 35GB | High-end Server |
+    
+    ## 🛠️ Where to Download
+    
+    ### **Primary Sources**
+    - **🤗 Hugging Face**: Largest repository with 400,000+ models
+    - **🦙 Ollama**: Simple CLI tool for local deployment
+    - **📦 LM Studio**: User-friendly GUI for model management
+    
+    ### **Quantized Formats**
+    - **GGUF**: Best for CPU inference (llama.cpp)
+    - **GPTQ**: GPU-optimized quantization
+    - **AWQ**: Advanced weight quantization
+    
+    ### **Download Tips**
+    - Use `git lfs` for large models from Hugging Face
+    - Consider bandwidth and storage before downloading
+    - Start with 4-bit quantized versions for testing
+    - Use `ollama pull model_name` for easiest setup
+    
+    ## 🔧 Optimization Strategies
+    
+    ### **Memory Reduction**
+    - **4-bit quantization**: 75% memory reduction
+    - **8-bit quantization**: 50% memory reduction
+    - **CPU offloading**: Use system RAM for overflow
+    
+    ### **Speed Optimization**
+    - **GPU acceleration**: CUDA, ROCm, Metal
+    - **Batch processing**: Process multiple requests
+    - **Context caching**: Reuse computations
+    """)
 
-    **General Purpose:**
-    - Llama-2 Series (7B, 13B, 70B)
-    - Mistral Series
-    - Gemma (2B, 7B)
+# Footer with updated resources
+st.markdown("---")
+st.markdown("""
+### 🔗 Essential Download & Deployment Tools
 
-    **Code Specialists:**
-    - CodeLlama
-    - CodeGen
+**📦 Easy Model Deployment:**
+- [**Ollama**](https://ollama.ai/) – `curl -fsSL https://ollama.ai/install.sh | sh`
+- [**LM Studio**](https://lmstudio.ai/) – Drag-and-drop GUI for running models locally
+- [**GPT4All**](https://gpt4all.io/) – Cross-platform desktop app for local LLMs
 
-    **Where to Download:**
-    - 🤗 Hugging Face Hub
-    - 🧙️ Ollama
-    - 📦 LM Studio
-    """)
+**🤗 Model Repositories:**
+- [**Hugging Face Hub**](https://huggingface.co/models) – Filter by model size, task, and license
+- [**TheBloke's Quantizations**](https://huggingface.co/TheBloke) – Pre-quantized models in GGUF/GPTQ format
+- [**Awesome LLM**](https://github.com/Hannibal046/Awesome-LLMs) – Curated list of models and resources
 
-st.markdown("---")
-st.markdown("*Built for BITS Pilani Interns*")
+
+---
+""")