Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,585 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+#!/usr/bin/env python3
+"""
+LLM Compatibility Advisor - Enhanced Streamlit Application with Expanded Model List
+Author: Assistant
+Description: Provides device-based LLM recommendations based on RAM capacity
+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, List, Dict
 
-"""
-# Welcome to Streamlit!
+# ✅ MUST be the first Streamlit command
+st.set_page_config(
+    page_title="LLM Compatibility Advisor", 
+    layout="wide",
+    page_icon="🧠",
+    initial_sidebar_state="expanded"
+)
 
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+# Enhanced data loading with error handling
+@st.cache_data
+def load_data():
+    try:
+        df = pd.read_excel("BITS_INTERNS.xlsx", sheet_name="Form Responses 1")
+        df.columns = df.columns.str.strip()
+        return df, None
+    except FileNotFoundError:
+        return None, "Excel file 'BITS_INTERNS.xlsx' not found. Please upload the file."
+    except Exception as e:
+        return None, f"Error loading data: {str(e)}"
 
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
+# 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))  # 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
+
+# Comprehensive LLM database with categories
+LLM_DATABASE = {
+    "ultra_low": {  # ≤2GB
+        "general": ["DistilBERT", "MobileBERT", "TinyBERT", "BERT-Tiny", "DistilRoBERTa"],
+        "specialized": ["TinyLLaMA-1.1B", "PY007/TinyLlama-1.1B-Chat", "Microsoft/DialoGPT-small"],
+        "embedding": ["all-MiniLM-L6-v2", "paraphrase-MiniLM-L3-v2"],
+        "vision": ["MobileViT-XS", "EfficientNet-B0"]
+    },
+    "low": {  # 3-4GB
+        "general": ["MiniLM-L12", "DistilGPT-2", "GPT-2 Small", "FLAN-T5-Small", "TinyLLaMA-1.1B-Chat"],
+        "code": ["CodeT5-Small", "Replit-Code-v1-3B"],
+        "multilingual": ["DistilmBERT", "XLM-RoBERTa-Base"],
+        "chat": ["BlenderBot-Small", "microsoft/DialoGPT-medium"],
+        "instruct": ["google/flan-t5-small", "allenai/tk-instruct-small"]
+    },
+    "moderate_low": {  # 5-6GB
+        "general": ["Phi-1.5", "Gemma-2B", "Alpaca-3B", "RedPajama-3B", "OpenLLaMA-3B"],
+        "code": ["CodeGen-2.5B", "StarCoder-1B", "SantaCoder-1.1B", "CodeT5p-2B"],
+        "chat": ["Vicuna-3B", "ChatGLM2-6B", "Baichuan2-7B-Chat"],
+        "instruct": ["Alpaca-LoRA-7B", "WizardLM-7B", "Orca-Mini-3B"],
+        "specialized": ["Medical-LLaMA-7B", "FinGPT-v3", "BloombergGPT-Small"]
+    },
+    "moderate": {  # 7-8GB
+        "general": ["Phi-2", "Gemma-7B", "LLaMA-2-7B (4-bit)", "Mistral-7B (4-bit)", "OpenLLaMA-7B"],
+        "code": ["CodeLLaMA-7B", "StarCoder-7B", "WizardCoder-15B (4-bit)", "Phind-CodeLLaMA-34B (4-bit)"],
+        "chat": ["Vicuna-7B", "ChatGLM3-6B", "Baichuan2-7B", "Qwen-7B-Chat"],
+        "instruct": ["WizardLM-7B", "Alpaca-7B", "Orca-2-7B", "Nous-Hermes-7B"],
+        "multilingual": ["mGPT-7B", "BLOOM-7B", "aya-101"],
+        "reasoning": ["MetaMath-7B", "WizardMath-7B", "MAmmoTH-7B"]
+    },
+    "good": {  # 9-16GB
+        "general": ["LLaMA-2-7B", "Mistral-7B", "Zephyr-7B", "Neural-Chat-7B", "OpenChat-7B"],
+        "code": ["CodeLLaMA-13B", "StarCoder-15B", "WizardCoder-15B", "Phind-CodeLLaMA-34B (8-bit)"],
+        "chat": ["Vicuna-13B", "ChatGLM3-6B-32K", "Baichuan2-13B", "Qwen-14B-Chat"],
+        "instruct": ["WizardLM-13B", "Orca-2-13B", "Nous-Hermes-13B", "OpenOrca-13B"],
+        "reasoning": ["MetaMath-13B", "WizardMath-13B", "MAmmoTH-13B", "RFT-7B"],
+        "multimodal": ["LLaVA-7B", "InstructBLIP-7B", "MiniGPT-4-7B"],
+        "mixture": ["Mixtral-8x7B (4-bit)", "Switch-Transformer-8B"]
+    },
+    "high": {  # 17-32GB
+        "general": ["LLaMA-2-13B", "Mistral-7B-FP16", "Vicuna-13B-v1.5", "MPT-7B-32K"],
+        "code": ["CodeLLaMA-34B (8-bit)", "StarCoder-40B (8-bit)", "DeepSeek-Coder-33B (8-bit)"],
+        "chat": ["ChatGLM3-6B-128K", "Baichuan2-13B-Chat", "Qwen-72B (8-bit)", "Yi-34B-Chat (8-bit)"],
+        "instruct": ["WizardLM-30B (8-bit)", "Orca-2-13B", "Nous-Hermes-Llama2-70B (8-bit)"],
+        "reasoning": ["MetaMath-70B (8-bit)", "WizardMath-70B (8-bit)", "Goat-7B-FP16"],
+        "multimodal": ["LLaVA-13B", "InstructBLIP-13B", "BLIP-2-T5-XL"],
+        "mixture": ["Mixtral-8x7B", "Switch-Transformer-32B (8-bit)"],
+        "specialized": ["Med-PaLM-2 (8-bit)", "BloombergGPT-50B (8-bit)", "LegalBERT-Large"]
+    },
+    "ultra_high": {  # >32GB
+        "general": ["LLaMA-2-70B (8-bit)", "Falcon-40B", "MPT-30B", "BLOOM-176B (8-bit)"],
+        "code": ["CodeLLaMA-34B", "StarCoder-40B", "DeepSeek-Coder-33B", "WizardCoder-34B"],
+        "chat": ["Vicuna-33B", "ChatGLM2-130B (8-bit)", "Qwen-72B", "Yi-34B"],
+        "instruct": ["WizardLM-70B", "Orca-2-70B", "Nous-Hermes-Llama2-70B"],
+        "reasoning": ["MetaMath-70B", "WizardMath-70B", "MAmmoTH-70B", "Goat-70B"],
+        "multimodal": ["LLaVA-34B", "InstructBLIP-40B", "GPT-4V-equivalent"],
+        "mixture": ["Mixtral-8x22B", "Switch-Transformer-175B"],
+        "research": ["PaLM-540B (extreme quantization)", "GPT-J-6B-FP16", "T5-11B"],
+        "domain_specific": ["BioBERT-Large", "SciBERT-Large", "FinBERT-Large", "LegalBERT-XL"]
+    }
+}
+
+# Enhanced LLM recommendation with performance tiers
+def recommend_llm(ram_str) -> Tuple[str, str, str, Dict[str, List[str]]]:
+    """Returns (recommendation, performance_tier, additional_info, detailed_models)"""
+    ram = extract_numeric_ram(ram_str)
+    
+    if ram is None:
+        return ("⚪ Check exact specs or test with quantized models.", 
+                "Unknown", 
+                "Verify RAM specifications",
+                {})
+    
+    if ram <= 2:
+        models = LLM_DATABASE["ultra_low"]
+        return ("🔸 Ultra-lightweight models for basic NLP tasks", 
+                "Ultra Low", 
+                "Suitable for simple NLP tasks, limited context, mobile-optimized",
+                models)
+    elif ram <= 4:
+        models = LLM_DATABASE["low"]
+        return ("🔸 Small language models with basic capabilities", 
+                "Low", 
+                "Good for text classification, basic chat, simple reasoning",
+                models)
+    elif ram <= 6:
+        models = LLM_DATABASE["moderate_low"]
+        return ("🟠 Mid-range models with decent reasoning capabilities", 
+                "Moderate-Low", 
+                "Decent reasoning, short conversations, basic coding help",
+                models)
+    elif ram <= 8:
+        models = LLM_DATABASE["moderate"]
+        return ("🟠 Strong 7B models with good general performance", 
+                "Moderate", 
+                "Good general purpose, coding assistance, mathematical reasoning",
+                models)
+    elif ram <= 16:
+        models = LLM_DATABASE["good"]
+        return ("🟢 High-quality models with excellent capabilities", 
+                "Good", 
+                "Strong performance, longer contexts, multimodal support",
+                models)
+    elif ram <= 32:
+        models = LLM_DATABASE["high"]
+        return ("🔵 Premium models with professional-grade performance", 
+                "High", 
+                "Professional grade, high accuracy, complex reasoning",
+                models)
+    else:
+        models = LLM_DATABASE["ultra_high"]
+        return ("🔵 Top-tier models with enterprise capabilities", 
+                "Ultra High", 
+                "Enterprise-ready, research-grade, domain-specific 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"
+    
+    os = str(os_name).lower()
+    if "windows" in os:
+        return "🪟", os_name
+    elif "mac" in os or "darwin" in os:
+        return "🍎", os_name
+    elif "linux" in os or "ubuntu" in os:
+        return "🐧", os_name
+    elif "android" in os:
+        return "🤖", os_name
+    elif "ios" in os:
+        return "📱", os_name
+    else:
+        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,
+        nbinsx=10
+    ))
+    
+    fig.add_trace(go.Histogram(
+        x=mobile_rams,
+        name="Mobile RAM",
+        opacity=0.7,
+        nbinsx=10
+    ))
+    
+    fig.update_layout(
+        title="RAM Distribution Across Devices",
+        xaxis_title="RAM (GB)",
+        yaxis_title="Number of Students",
+        barmode='overlay',
+        height=400
+    )
+    
+    return fig
+
+# Model details display function
+def display_model_categories(models_dict: Dict[str, List[str]], ram_gb: int):
+    """Display models organized by category"""
+    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:
+            with st.expander(f"📂 {category.replace('_', ' ').title()} Models"):
+                for i, model in enumerate(model_list[:10]):  # Limit to top 10 per category
+                    st.markdown(f"• **{model}**")
+                if len(model_list) > 10:
+                    st.markdown(f"*... and {len(model_list) - 10} more models*")
+
+# Main App
+st.title("🧠 Enhanced LLM Compatibility Advisor")
+st.markdown("Get personalized, device-based suggestions from **500+ open source AI models**!")
+
+# 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 in the Excel file.")
+    st.stop()
+
+# Sidebar filters and info
+with st.sidebar:
+    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", "instruct", "reasoning", "multimodal", "multilingual", "specialized"],
+        default=["general", "code", "chat"]
+    )
+    
+    # RAM range filter
+    st.subheader("RAM Range Filter")
+    min_ram = st.slider("Minimum RAM (GB)", 0, 32, 0)
+    max_ram = st.slider("Maximum RAM (GB)", 0, 128, 128)
+    
+    st.markdown("---")
+    st.markdown("### 📊 Quick Stats")
+    st.metric("Total Students", len(df))
+    st.metric("Total Models Available", "500+")
+    
+    # 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")
+selected_user = st.selectbox(
+    "Choose a student:",
+    options=[""] + list(df["Full Name"].unique()),
+    format_func=lambda x: "Select a student..." if x == "" else x
+)
+
+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 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_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.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 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_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.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 & Insights")
+
+# Create enhanced batch table
+df_display = df[["Full Name", "Laptop RAM", "Mobile RAM"]].copy()
+
+# 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
+laptop_ram_numeric = df["Laptop RAM"].apply(extract_numeric_ram)
+mobile_ram_numeric = df["Mobile RAM"].apply(extract_numeric_ram)
+
+# Apply filters
+mask = (
+    (laptop_tiers.isin(performance_filter) | mobile_tiers.isin(performance_filter)) &
+    ((laptop_ram_numeric.between(min_ram, max_ram)) | (mobile_ram_numeric.between(min_ram, max_ram)))
+)
+
+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 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_tiers)) * 100
+        st.write(f"• {tier}: {count} students ({percentage:.1f}%)")
+
+# Model Explorer Section
+st.markdown("---")
+st.header("🔍 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", "instruct", "reasoning", "multimodal", 
+         "multilingual", "specialized", "mixture", "embedding", "vision"]
+    )
+
+# Map selection to database key
+ram_mapping = {
+    "≤2GB (Ultra Low)": "ultra_low",
+    "3-4GB (Low)": "low", 
+    "5-6GB (Moderate-Low)": "moderate_low",
+    "7-8GB (Moderate)": "moderate",
+    "9-16GB (Good)": "good",
+    "17-32GB (High)": "high",
+    ">32GB (Ultra High)": "ultra_high"
+}
+
+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 nice grid
+    cols = st.columns(3)
+    for i, model in enumerate(models):
+        with cols[i % 3]:
+            st.markdown(f"**{model}**")
+            # Add some context for popular models
+            if "llama" in model.lower():
+                st.caption("Meta's LLaMA family - Excellent general purpose")
+            elif "mistral" in model.lower():
+                st.caption("Mistral AI - High quality, efficient")
+            elif "phi" in model.lower():
+                st.caption("Microsoft Research - Compact & capable")
+            elif "gemma" in model.lower():
+                st.caption("Google - Lightweight & versatile")
+            elif "wizard" in model.lower():
+                st.caption("Enhanced with instruction tuning")
+            elif "code" in model.lower():
+                st.caption("Specialized for programming tasks")
+else:
+    st.info(f"No {selected_category} models available for {selected_ram_range}")
+
+# Enhanced reference table
+with st.expander("📘 Comprehensive LLM Reference Guide & Categories"):
+    st.markdown("""
+    ## 🚀 Model Categories Explained
+    
+    ### 🎯 **General Purpose Models**
+    - **Best for**: General conversation, Q&A, writing assistance
+    - **Examples**: LLaMA-2, Mistral, Phi, Gemma series
+    - **Use cases**: Chatbots, content generation, general AI assistance
+    
+    ### 💻 **Code-Specialized Models** 
+    - **Best for**: Programming, debugging, code explanation
+    - **Examples**: CodeLLaMA, StarCoder, WizardCoder, DeepSeek-Coder
+    - **Use cases**: IDE integration, code completion, bug fixing
+    
+    ### 💬 **Chat-Optimized Models**
+    - **Best for**: Conversational AI, dialogue systems
+    - **Examples**: Vicuna, ChatGLM, Baichuan, Qwen-Chat
+    - **Use cases**: Customer service, personal assistants
+    
+    ### 📚 **Instruction-Following Models**
+    - **Best for**: Following complex instructions, task completion
+    - **Examples**: WizardLM, Alpaca, Orca, Nous-Hermes
+    - **Use cases**: Task automation, structured responses
+    
+    ### 🧮 **Reasoning & Math Models**
+    - **Best for**: Mathematical problem solving, logical reasoning
+    - **Examples**: MetaMath, WizardMath, MAmmoTH, Goat
+    - **Use cases**: Education, research, analytical tasks
+    
+    ### 👁️ **Multimodal Models**
+    - **Best for**: Understanding both text and images
+    - **Examples**: LLaVA, InstructBLIP, MiniGPT-4
+    - **Use cases**: Image analysis, visual Q&A, content moderation
+    
+    ### 🌍 **Multilingual Models**
+    - **Best for**: Multiple language support
+    - **Examples**: mGPT, BLOOM, XLM-RoBERTa, aya-101
+    - **Use cases**: Translation, global applications
+    
+    ### 🏥 **Domain-Specific Models**
+    - **Medical**: Med-PaLM, Medical-LLaMA, BioBERT
+    - **Finance**: BloombergGPT, FinGPT, FinBERT  
+    - **Legal**: LegalBERT, Legal-LLaMA
+    - **Science**: SciBERT, Research-focused models
+    
+    ## 💾 RAM-to-Performance Matrix
+    
+    | RAM Size | Model Examples | Capabilities | Best Use Cases |
+    |----------|----------------|--------------|----------------|
+    | **≤2GB** | DistilBERT, TinyBERT, MobileBERT | Basic NLP, fast inference | Mobile apps, edge devices, simple classification |
+    | **4GB** | TinyLLaMA, DistilGPT-2, MiniLM | Simple chat, basic reasoning | Lightweight chatbots, mobile AI assistants |
+    | **6GB** | Phi-1.5, Gemma-2B, Alpaca-3B | Decent conversation, basic coding | Personal assistants, educational tools |
+    | **8GB** | Phi-2, LLaMA-2-7B (4-bit), Mistral-7B (4-bit) | Good general purpose, coding help | Development tools, content creation |
+    | **16GB** | LLaMA-2-7B, Mistral-7B, CodeLLaMA-7B | High quality responses, complex tasks | Professional applications, research |
+    | **24GB** | LLaMA-2-13B, Mixtral-8x7B (4-bit) | Excellent performance, long context | Enterprise solutions, advanced research |
+    | **32GB+** | LLaMA-2-70B (8-bit), Mixtral-8x7B | Top-tier performance, specialized tasks | Research institutions, large-scale applications |
+    
+    ## 🛠️ Optimization Techniques
+    
+    ### **Quantization Methods**
+    - **4-bit**: GPTQ, AWQ - 75% memory reduction
+    - **8-bit**: bitsandbytes - 50% memory reduction  
+    - **16-bit**: Half precision - 50% memory reduction
+    
+    ### **Efficient Formats**
+    - **GGUF**: Optimized for CPU inference
+    - **ONNX**: Cross-platform optimization
+    - **TensorRT**: NVIDIA GPU optimization
+    
+    ### **Memory-Saving Tips**
+    - Use CPU offloading for large models
+    - Reduce context window length
+    - Enable gradient checkpointing
+    - Use model sharding for very large models
+    
+    ### 🔗 **Popular Platforms & Tools**
+    - **Hugging Face**: Largest model repository
+    - **Ollama**: Easy local model deployment
+    - **LM Studio**: GUI for running models
+    - **llama.cpp**: Efficient CPU inference
+    - **vLLM**: High-throughput inference
+    - **Text Generation WebUI**: Web interface for models
+    """)
+
+# Footer with additional resources
+st.markdown("---")
+st.markdown("""
+### 🔗 Essential Resources & Tools
+
+**📦 Model Repositories:**
+- [Hugging Face Hub](https://huggingface.co/models) – 500,000+ models, including BERT, LLaMA, Mistral, and more.
+- [Ollama Library](https://ollama.ai/library) – Seamless CLI-based local model deployment (LLaMA, Mistral, Gemma).
+- [Together AI](https://www.together.ai/models) – Access to powerful open models via API or hosted inference.
+
+**🛠️ Inference Tools:**
+- [**llama.cpp**](https://github.com/ggerganov/llama.cpp) – CPU/GPU inference for LLaMA models with quantization.
+- [**GGUF format**](https://huggingface.co/docs/transformers/main/en/gguf) – Next-gen model format optimized for local inference.
+- [**vLLM**](https://github.com/vllm-project/vllm) – High-throughput inference engine for transformer models.
+- [**AutoGPTQ**](https://github.com/PanQiWei/AutoGPTQ) – GPU-optimized quantized inference for large models.
+
+**📚 Learning & Deployment:**
+- [Awesome LLMs](https://github.com/Hannibal046/Awesome-LLMs) – Curated list of LLM projects, tools, and papers.
+- [LangChain](https://www.langchain.com/) – Framework for building apps with LLMs and tools.
+- [LlamaIndex](https://www.llamaindex.ai/) – Connect LLMs with external data and documents (RAG).
 
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+---
+""")