Update app.py

app.py

@@ -5,338 +5,586 @@ import json
 import os
 import time
 from datetime import datetime
+import traceback
 
-# Custom system instructions for business category descriptions
-SYSTEM_INSTRUCTIONS = """You are an expert at writing clear and visual descriptions for a business category keyword for a yellow pages or business listing website. Given a category keyword, generate a single, detailed description that defines its key visual elements, location, and context. Do not add artistic or stylistic flair. Ensure that the description is CLIP model ready and not too verbose.
+# Model configurations with their strengths
+MODEL_CONFIGS = {
+    "Meta Llama 3.1 70B Instruct (Best Quality)": {
+        "model_id": "meta-llama/Meta-Llama-3.1-70B-Instruct",
+        "description": "Excellent for creative and detailed descriptions",
+        "default_temp": 0.3,
+        "max_tokens": 300
+    },
+    "Qwen 2.5 72B Instruct (Fast & Accurate)": {
+        "model_id": "Qwen/Qwen2.5-72B-Instruct",
+        "description": "Great balance of speed and quality",
+        "default_temp": 0.35,
+        "max_tokens": 300
+    },
+    "GPT-OSS 20B (Original)": {
+        "model_id": "openai/gpt-oss-20b",
+        "description": "Your current model - good for structured output",
+        "default_temp": 0.3,
+        "max_tokens": 256
+    },
+    "Mixtral 8x7B (Efficient)": {
+        "model_id": "mistralai/Mixtral-8x7B-Instruct-v0.1",
+        "description": "Fast processing for large batches",
+        "default_temp": 0.4,
+        "max_tokens": 300
+    }
+}
 
-Here are some examples of the correct format:
+# Different system prompts for different description styles
+PROMPT_TEMPLATES = {
+    "Clip-Ready Visual (15-30 words)": """You are an expert at writing ultra-concise, visual descriptions for CLIP models and image search.
 
-Category: "Car Rental For Self Driven"
+For each business category, create a description that:
+1. Is 15-30 words maximum
+2. Focuses on VISUAL elements only (what you would SEE in an image)
+3. Uses concrete, observable details
+4. Avoids abstract concepts or services
+5. Describes physical appearance, setting, or visual activity
 
-Description: "a car available for self-drive rental, parked at a pickup spot without a chauffeur; looks travel-ready, clean, well-maintained, keys handed over to customer"
+Examples:
+Category: "Car Rental"
+Description: "rental car with keys, parked at pickup location, clean interior visible, rental company signage"
 
-Category: "Mehandi"
+Category: "Yoga Classes"
+Description: "people in yoga poses on mats, stretching in studio with mirrors, instructor demonstrating position"
 
-Description: "Temporary henna artwork applied on hands and feet using cones; fine brown or maroon floral and paisley patterns, mandalas, and lace-like detailing, commonly seen at weddings and festivals."
+IMPORTANT: Respond with ONLY a JSON object:
+{"Category": "category name", "Description": "visual description"}""",
 
-Category: "Photographer"
+    "Standard Business (40-60 words)": """You are creating professional business descriptions for directory listings.
 
-Description: "a person actively shooting photos or posing with a camera; holding a camera to eye, adjusting lens, or directing a subject during a shoot"
+Generate descriptions that:
+1. Are 40-60 words
+2. Define the service clearly
+3. Include key visual and contextual elements
+4. Are suitable for yellow pages or business directories
+5. Focus on what customers would see or experience
 
-Category: "Equipment"
+Examples:
+Category: "Photography Studio"
+Description: "Professional photography space with lighting equipment, backdrops, and cameras. Photographer capturing portraits, events, or products. Studio setup with tripods, reflectors, softboxes. Clients posing for shots, reviewing images on screens. Portfolio displays, editing workstations visible."
 
-Description: "lighting stands, softboxes, strobes, tripods, reflectors, gimbals, battery packs, memory cards arranged as gear kits"
+IMPORTANT: Respond with ONLY a JSON object:
+{"Category": "category name", "Description": "description text"}""",
 
----
+    "E-commerce Ready (30-50 words)": """You are writing descriptions optimized for e-commerce and online marketplaces.
 
-IMPORTANT: You must respond with ONLY a valid JSON object in this exact format:
-{"Category": "category name", "Description": "description text"}
+Create descriptions that:
+1. Are 30-50 words
+2. Highlight visual product/service attributes
+3. Include searchable keywords
+4. Focus on customer benefits
+5. Use action-oriented language
 
-Do not include any other text, explanations, or markdown formatting. Only output the JSON object."""
+IMPORTANT: Respond with ONLY a JSON object:
+{"Category": "category name", "Description": "description text"}""",
 
+    "Custom Prompt": ""  # Will be filled by user
+}
 
-def extract_json_from_response(response_text):
-    """Extract and validate JSON from model response."""
-    # Try to find JSON in the response
-    response_text = response_text.strip()
+class EnhancedDescriptionGenerator:
+    def __init__(self):
+        self.clients = {}
+        self.initialize_clients()
     
-    # Remove markdown code blocks if present
-    if "```json" in response_text:
-        response_text = response_text.split("```json")[1].split("```")[0].strip()
-    elif "```" in response_text:
-        response_text = response_text.split("```")[1].split("```")[0].strip()
-    
-    # Try to find JSON object in the text
-    if "{" in response_text and "}" in response_text:
-        start = response_text.find("{")
-        end = response_text.rfind("}") + 1
-        response_text = response_text[start:end]
-    
-    # Parse JSON
-    parsed = json.loads(response_text)
-    
-    # Validate structure
-    if not isinstance(parsed, dict):
-        raise ValueError("Response is not a JSON object")
-    
-    # Get description with various possible keys
-    description = (
-        parsed.get("Description") or 
-        parsed.get("description") or 
-        parsed.get("desc") or 
-        ""
-    )
-    
-    if not description or len(description.strip()) < 10:
-        raise ValueError("Description is missing or too short")
-    
-    return description.strip()
-
-
-def process_single_category(category, client, max_tokens, temperature, top_p, retry_count=3):
-    """Process a single category keyword and return the description with retry logic."""
-    messages = [
-        {"role": "system", "content": SYSTEM_INSTRUCTIONS},
-        {"role": "user", "content": f"Category: \"{category}\""}
-    ]
-    
-    last_error = None
+    def initialize_clients(self):
+        """Initialize all model clients"""
+        hf_token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_TOKEN")
+        
+        if not hf_token:
+            raise ValueError("HF_TOKEN not found in environment variables")
+        
+        for model_name, config in MODEL_CONFIGS.items():
+            try:
+                self.clients[model_name] = InferenceClient(
+                    token=hf_token,
+                    model=config["model_id"]
+                )
+                print(f"✅ Initialized: {model_name}")
+            except Exception as e:
+                print(f"⚠️ Failed to initialize {model_name}: {str(e)}")
+                self.clients[model_name] = None
     
-    for attempt in range(retry_count):
+    def extract_json_from_response(self, response_text):
+        """Enhanced JSON extraction with multiple fallback methods"""
+        if not response_text:
+            raise ValueError("Empty response")
+        
+        response_text = response_text.strip()
+        
+        # Method 1: Clean markdown formatting
+        if "```json" in response_text:
+            response_text = response_text.split("```json")[1].split("```")[0].strip()
+        elif "```" in response_text:
+            response_text = response_text.split("```")[1].split("```")[0].strip()
+        
+        # Method 2: Extract JSON object
+        if "{" in response_text and "}" in response_text:
+            start = response_text.find("{")
+            end = response_text.rfind("}") + 1
+            json_str = response_text[start:end]
+        else:
+            json_str = response_text
+        
+        # Try to parse JSON
         try:
-            # Add small delay between retries
-            if attempt > 0:
-                time.sleep(1)
-            
-            # Try streaming approach (more reliable for this model)
-            response_text = ""
-            for message in client.chat_completion(
-                messages,
-                max_tokens=max_tokens,
-                stream=True,
-                temperature=temperature,
-                top_p=top_p,
-            ):
-                if hasattr(message, 'choices') and len(message.choices) > 0:
-                    if hasattr(message.choices[0], 'delta') and hasattr(message.choices[0].delta, 'content'):
-                        token = message.choices[0].delta.content
-                        if token:
-                            response_text += token
-                elif isinstance(message, str):
-                    response_text += message
-            
-            # Validate we got a response
-            if not response_text or len(response_text.strip()) < 5:
-                raise ValueError("Empty or too short response from model")
-            
-            # Extract and validate JSON
-            description = extract_json_from_response(response_text)
-            
-            # Return both the description and raw response
-            return response_text.strip(), description
-            
-        except json.JSONDecodeError as e:
-            last_error = f"JSON parsing failed (attempt {attempt + 1}/{retry_count}): {str(e)}"
-            # If JSON parsing fails, try to extract description from raw text
-            if attempt == retry_count - 1 and response_text:
-                # Last attempt - try to use raw response if it looks like a description
-                if len(response_text.strip()) > 20 and not response_text.startswith("{"):
-                    return response_text.strip(), response_text.strip()
-        except Exception as e:
-            last_error = f"Processing failed (attempt {attempt + 1}/{retry_count}): {str(e)}"
+            parsed = json.loads(json_str)
+        except json.JSONDecodeError:
+            # Method 3: Try to fix common JSON issues
+            json_str = json_str.replace("'", '"')  # Replace single quotes
+            json_str = json_str.replace("\n", " ")  # Remove newlines
+            json_str = json_str.replace("\\", "\\\\")  # Escape backslashes
+            parsed = json.loads(json_str)
+        
+        # Validate and extract description
+        if not isinstance(parsed, dict):
+            raise ValueError("Response is not a JSON object")
+        
+        description = (
+            parsed.get("Description") or 
+            parsed.get("description") or 
+            parsed.get("Desc") or 
+            parsed.get("desc") or 
+            ""
+        )
+        
+        if not description or len(description.strip()) < 10:
+            raise ValueError("Description is missing or too short")
+        
+        return description.strip()
     
-    # All retries failed
-    raise Exception(f"Failed after {retry_count} attempts. Last error: {last_error}")
-
+    def process_single_category(
+        self,
+        category,
+        model_name,
+        prompt_template,
+        custom_prompt,
+        max_tokens,
+        temperature,
+        top_p,
+        retry_count=3
+    ):
+        """Process a single category with the selected model and prompt"""
+        
+        client = self.clients.get(model_name)
+        if not client:
+            return None, f"Model {model_name} not available"
+        
+        # Select and prepare the prompt
+        if prompt_template == "Custom Prompt":
+            if not custom_prompt:
+                return None, "Custom prompt is required when 'Custom Prompt' is selected"
+            system_prompt = custom_prompt
+        else:
+            system_prompt = PROMPT_TEMPLATES[prompt_template]
+        
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": f"Category: \"{category}\""}
+        ]
+        
+        last_error = None
+        
+        for attempt in range(retry_count):
+            try:
+                if attempt > 0:
+                    time.sleep(1)
+                
+                # Make API call
+                response_text = ""
+                for message in client.chat_completion(
+                    messages,
+                    max_tokens=max_tokens,
+                    stream=True,
+                    temperature=temperature,
+                    top_p=top_p,
+                ):
+                    if hasattr(message, 'choices') and len(message.choices) > 0:
+                        if hasattr(message.choices[0], 'delta') and hasattr(message.choices[0].delta, 'content'):
+                            token = message.choices[0].delta.content
+                            if token:
+                                response_text += token
+                    elif isinstance(message, str):
+                        response_text += message
+                
+                # Validate response
+                if not response_text or len(response_text.strip()) < 5:
+                    raise ValueError("Empty or too short response")
+                
+                # Extract description
+                description = self.extract_json_from_response(response_text)
+                
+                # Count words for validation
+                word_count = len(description.split())
+                
+                return response_text.strip(), description, word_count
+                
+            except Exception as e:
+                last_error = f"Attempt {attempt + 1}/{retry_count}: {str(e)}"
+                
+                # On last attempt, try to use raw response if it looks valid
+                if attempt == retry_count - 1 and response_text:
+                    if len(response_text.strip()) > 20 and not response_text.startswith("{"):
+                        return response_text.strip(), response_text.strip(), len(response_text.split())
+        
+        raise Exception(f"Failed after {retry_count} attempts. Last error: {last_error}")
 
-def process_csv_files(
+def process_csv_advanced(
     files,
     category_column,
+    model_name,
+    prompt_template,
+    custom_prompt,
     max_tokens,
     temperature,
     top_p,
+    output_format,
     progress=gr.Progress()
 ):
-    """
-    Process multiple CSV files and generate descriptions for category keywords.
-    """
+    """Enhanced CSV processing with multiple models and output formats"""
+    
     if not files or len(files) == 0:
-        return "Please upload at least one CSV file.", None
+        return "Please upload at least one CSV file.", None, None
     
-    # Get HF token from environment variables
-    import os
+    # Check for HF token
     hf_token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_TOKEN")
-    
     if not hf_token:
-        return "❌ Error: HF_TOKEN not found. Please add your Hugging Face token as a Space Secret.\n\nGo to Space Settings → Secrets → Add 'HF_TOKEN'", None
+        return "⚠️ Error: HF_TOKEN not found. Please add your Hugging Face token as a Space Secret.", None, None
     
-    client = InferenceClient(token=hf_token, model="openai/gpt-oss-20b")
+    # Initialize generator
+    try:
+        generator = EnhancedDescriptionGenerator()
+    except Exception as e:
+        return f"Error initializing models: {str(e)}", None, None
     
-    output_files = []
+    all_results = []
     status_messages = []
+    output_files = []
     
     for file_idx, file in enumerate(files):
         try:
-            # Read CSV file
+            # Read CSV
             df = pd.read_csv(file.name)
-            status_messages.append(f"📄 Processing file {file_idx + 1}/{len(files)}: {os.path.basename(file.name)}")
+            file_name = os.path.basename(file.name)
+            status_messages.append(f"📄 Processing file {file_idx + 1}/{len(files)}: {file_name}")
             
-            # Check if category column exists
+            # Check column exists
             if category_column not in df.columns:
-                status_messages.append(f"⚠️ Warning: Column '{category_column}' not found in {os.path.basename(file.name)}. Available columns: {', '.join(df.columns)}")
+                status_messages.append(f"⚠️ Column '{category_column}' not found in {file_name}. Available: {', '.join(df.columns)}")
                 continue
             
-            # Process each category
-            descriptions = []
-            raw_responses = []
-            
+            # Process categories
             categories = df[category_column].dropna().unique()
             total_categories = len(categories)
             
+            file_results = []
+            
             for idx, category in enumerate(categories):
-                progress((file_idx * total_categories + idx) / (len(files) * total_categories), 
-                        desc=f"Processing category {idx + 1}/{total_categories} in file {file_idx + 1}")
+                progress(
+                    (file_idx * total_categories + idx) / (len(files) * total_categories),
+                    desc=f"File {file_idx + 1}/{len(files)} - Category {idx + 1}/{total_categories}: {category[:30]}..."
+                )
                 
                 try:
-                    # Process with retry logic
-                    raw_response, description = process_single_category(
-                        category, client, max_tokens, temperature, top_p, retry_count=3
+                    raw_response, description, word_count = generator.process_single_category(
+                        category,
+                        model_name,
+                        prompt_template,
+                        custom_prompt,
+                        max_tokens,
+                        temperature,
+                        top_p
                     )
                     
-                    # Validate description
-                    if not description or len(description.strip()) < 10:
-                        raise ValueError("Description is too short or empty")
-                    
-                    descriptions.append({
+                    result = {
+                        "File": file_name,
                         "Category": category,
                         "Description": description,
+                        "Word_Count": word_count,
+                        "Model": model_name,
+                        "Prompt_Type": prompt_template,
                         "Raw_Response": raw_response,
                         "Status": "Success"
-                    })
+                    }
                     
-                    status_messages.append(f"✅ Processed: {category}")
+                    file_results.append(result)
+                    all_results.append(result)
+                    status_messages.append(f"✅ {category[:30]}... ({word_count} words)")
                     
                 except Exception as e:
-                    error_msg = str(e)
-                    status_messages.append(f"⚠️ Error processing '{category}': {error_msg}")
-                    
-                    descriptions.append({
+                    error_msg = str(e)[:100]
+                    result = {
+                        "File": file_name,
                         "Category": category,
-                        "Description": f"[FAILED - {error_msg[:100]}]",
+                        "Description": f"[FAILED: {error_msg}]",
+                        "Word_Count": 0,
+                        "Model": model_name,
+                        "Prompt_Type": prompt_template,
                         "Raw_Response": "",
-                        "Status": "Failed"
-                    })
+                        "Status": f"Failed: {error_msg}"
+                    }
+                    
+                    file_results.append(result)
+                    all_results.append(result)
+                    status_messages.append(f"❌ {category[:30]}... - {error_msg}")
                 
-                # Small delay to avoid rate limiting
-                time.sleep(0.5)
-            
-            # Create output dataframe
-            output_df = pd.DataFrame(descriptions)
+                # Rate limiting
+                time.sleep(0.3)
             
-            # Save to file
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            base_name = os.path.splitext(os.path.basename(file.name))[0]
-            output_filename = f"output_{base_name}_{timestamp}.csv"
-            output_df.to_csv(output_filename, index=False)
-            output_files.append(output_filename)
+            # Create output file for this CSV
+            if file_results:
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                base_name = os.path.splitext(file_name)[0]
+                
+                if output_format in ["CSV", "Both"]:
+                    csv_filename = f"output_{base_name}_{timestamp}.csv"
+                    pd.DataFrame(file_results).to_csv(csv_filename, index=False)
+                    output_files.append(csv_filename)
+                
+                if output_format in ["JSON", "Both"]:
+                    json_filename = f"output_{base_name}_{timestamp}.json"
+                    with open(json_filename, 'w') as f:
+                        json.dump(file_results, f, indent=2)
+                    output_files.append(json_filename)
             
-            # Count successes and failures
-            success_count = len([d for d in descriptions if d.get("Status") == "Success"])
-            failed_count = len([d for d in descriptions if d.get("Status") == "Failed"])
+            # Summary for this file
+            success_count = sum(1 for r in file_results if r["Status"] == "Success")
+            failed_count = len(file_results) - success_count
+            avg_words = sum(r["Word_Count"] for r in file_results if r["Status"] == "Success") / max(success_count, 1)
             
-            status_messages.append(f"✅ Completed: {success_count} succeeded, {failed_count} failed out of {len(descriptions)} categories from {os.path.basename(file.name)}")
+            status_messages.append(f"""
+📊 {file_name} Summary:
+   - Total: {len(file_results)} categories
+   - Success: {success_count} ({success_count/len(file_results)*100:.1f}%)
+   - Failed: {failed_count}
+   - Avg Words: {avg_words:.1f}
+""")
             
         except Exception as e:
             status_messages.append(f"❌ Error processing {os.path.basename(file.name)}: {str(e)}")
     
-    status_text = "\n".join(status_messages)
-    
-    if output_files:
-        return status_text, output_files
-    else:
-        return status_text + "\n\n❌ No output files generated.", None
+    # Overall summary
+    if all_results:
+        total_success = sum(1 for r in all_results if r["Status"] == "Success")
+        total_failed = len(all_results) - total_success
+        
+        summary = f"""
+## 🎯 Processing Complete!
 
+**Model Used:** {model_name}
+**Prompt Template:** {prompt_template}
 
-# Create Gradio interface
-with gr.Blocks(title="Business Category Description Generator") as demo:
-    gr.Markdown("""
-    # 🏢 Business Category Description Generator
-    
-    Upload CSV files containing business category keywords, and this app will generate 
-    CLIP-ready visual descriptions for each category using AI.
-    
-    **Instructions:**
-    1. Upload one or more CSV files
-    2. Specify the column name that contains the category keywords
-    3. Adjust model settings (lower temperature = more consistent output)
-    4. Click "Process Files" to generate descriptions
-    5. Download the output CSV files with Status column
-    
-    **Features:**
-    - ✅ Automatic retry logic (3 attempts per category)
-    - ✅ JSON validation and error recovery
-    - ✅ Progress tracking with detailed status
-    - ✅ Success/failure reporting
-    
-    *Note: For faster processing, use Zero GPU (see Space Settings). Authentication via HF_TOKEN secret.*
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### ⚙️ Model Settings")
-            max_tokens = gr.Slider(
-                minimum=64, 
-                maximum=512, 
-                value=256, 
-                step=16, 
-                label="Max Tokens"
-            )
-            temperature = gr.Slider(
-                minimum=0.1, 
-                maximum=1.0, 
-                value=0.3, 
-                step=0.1, 
-                label="Temperature",
-                info="Lower = more consistent output"
-            )
-            top_p = gr.Slider(
-                minimum=0.1, 
-                maximum=1.0, 
-                value=0.9, 
-                step=0.05, 
-                label="Top-p"
-            )
+### Overall Statistics:
+- **Total Categories Processed:** {len(all_results)}
+- **Successful:** {total_success} ({total_success/len(all_results)*100:.1f}%)
+- **Failed:** {total_failed} ({total_failed/len(all_results)*100:.1f}%)
+- **Average Word Count:** {sum(r['Word_Count'] for r in all_results if r['Status'] == 'Success') / max(total_success, 1):.1f}
+
+### File Processing Log:
+"""
+        status_text = summary + "\n".join(status_messages)
+        
+        # Create combined output file
+        if output_format in ["CSV", "Both"]:
+            combined_csv = f"combined_output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+            pd.DataFrame(all_results).to_csv(combined_csv, index=False)
+            output_files.append(combined_csv)
+        
+        if output_format in ["JSON", "Both"]:
+            combined_json = f"combined_output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+            with open(combined_json, 'w') as f:
+                json.dump(all_results, f, indent=2)
+            output_files.append(combined_json)
+        
+        # Create summary DataFrame for display
+        summary_df = pd.DataFrame(all_results)[['Category', 'Description', 'Word_Count', 'Status']]
+        
+        return status_text, output_files, summary_df
+    else:
+        return "\n".join(status_messages) + "\n\n⚠️ No categories were processed successfully.", None, None
+
+# Create enhanced Gradio interface
+def create_interface():
+    with gr.Blocks(title="Enhanced Business Description Generator", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 🚀 Enhanced Multi-Model Business Description Generator
+        
+        Generate professional, clip-ready descriptions using multiple state-of-the-art AI models.
+        
+        ### ✨ New Features:
+        - 🤖 **4 Different AI Models** to choose from
+        - 📝 **Multiple Prompt Templates** for different use cases
+        - 📊 **Word Count Tracking** for all descriptions
+        - 💾 **CSV & JSON Export** options
+        - 📈 **Enhanced Statistics** and success tracking
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📤 Input Configuration")
+                
+                files_input = gr.File(
+                    label="Upload CSV Files",
+                    file_count="multiple",
+                    file_types=[".csv"]
+                )
+                
+                category_column = gr.Textbox(
+                    label="Category Column Name",
+                    value="category",
+                    placeholder="Column containing categories"
+                )
+                
+                gr.Markdown("### 🤖 Model Selection")
+                
+                model_selector = gr.Dropdown(
+                    label="Select AI Model",
+                    choices=list(MODEL_CONFIGS.keys()),
+                    value=list(MODEL_CONFIGS.keys())[0],
+                    info="Each model has different strengths"
+                )
+                
+                # Model description display
+                model_info = gr.Markdown("")
+                
+                prompt_template = gr.Dropdown(
+                    label="Prompt Template",
+                    choices=list(PROMPT_TEMPLATES.keys()),
+                    value="Clip-Ready Visual (15-30 words)",
+                    info="Choose based on your use case"
+                )
+                
+                custom_prompt = gr.Textbox(
+                    label="Custom System Prompt (if Custom selected)",
+                    placeholder="Enter your custom instructions here...",
+                    lines=4,
+                    visible=False
+                )
+                
+                gr.Markdown("### ⚙️ Generation Settings")
+                
+                with gr.Row():
+                    temperature = gr.Slider(
+                        minimum=0.1,
+                        maximum=1.0,
+                        value=0.3,
+                        step=0.05,
+                        label="Temperature",
+                        info="Lower = consistent, Higher = creative"
+                    )
+                    
+                    top_p = gr.Slider(
+                        minimum=0.1,
+                        maximum=1.0,
+                        value=0.9,
+                        step=0.05,
+                        label="Top-p"
+                    )
+                
+                max_tokens = gr.Slider(
+                    minimum=64,
+                    maximum=512,
+                    value=256,
+                    step=16,
+                    label="Max Tokens"
+                )
+                
+                output_format = gr.Radio(
+                    label="Output Format",
+                    choices=["CSV", "JSON", "Both"],
+                    value="CSV"
+                )
+                
+                process_btn = gr.Button("🚀 Generate Descriptions", variant="primary", size="lg")
+            
+            with gr.Column(scale=2):
+                gr.Markdown("### 📊 Results")
+                
+                status_output = gr.Markdown(label="Processing Status")
+                
+                results_preview = gr.Dataframe(
+                    label="Results Preview",
+                    headers=["Category", "Description", "Word_Count", "Status"],
+                    datatype=["str", "str", "number", "str"],
+                    col_count=4,
+                    wrap=True
+                )
+                
+                files_output = gr.File(
+                    label="📥 Download Output Files",
+                    file_count="multiple"
+                )
         
-        with gr.Column(scale=2):
-            files_input = gr.File(
-                label="📤 Upload CSV Files",
-                file_count="multiple",
-                file_types=[".csv"]
-            )
-            category_column = gr.Textbox(
-                label="📝 Category Column Name",
-                value="category",
-                placeholder="Enter the name of the column containing categories"
-            )
-            process_btn = gr.Button("🚀 Process Files", variant="primary", size="lg")
+        with gr.Row():
+            gr.Markdown("""
+            ### 💡 Model Recommendations:
             
-            status_output = gr.Textbox(
-                label="📊 Status",
-                lines=10,
-                interactive=False
-            )
-            files_output = gr.File(
-                label="💾 Download Output Files",
-                file_count="multiple"
-            )
-    
-    process_btn.click(
-        fn=process_csv_files,
-        inputs=[
-            files_input,
-            category_column,
-            max_tokens,
-            temperature,
-            top_p
-        ],
-        outputs=[status_output, files_output]
-    )
-    
-    gr.Markdown("""
-    ---
-    ### 📝 Output Format
-    Each output CSV file will contain:
-    - **Category**: The original category keyword
-    - **Description**: The generated visual description (validated and cleaned)
-    - **Raw_Response**: The complete model response (for debugging)
-    - **Status**: Success or Failed (with error details)
+            | Model | Best For | Speed | Quality |
+            |-------|----------|-------|---------|
+            | **Llama 3.1 70B** | Creative, detailed descriptions | Medium | ⭐⭐⭐⭐⭐ |
+            | **Qwen 2.5 72B** | Balanced performance | Fast | ⭐⭐⭐⭐ |
+            | **GPT-OSS 20B** | Structured, consistent output | Fast | ⭐⭐⭐⭐ |
+            | **Mixtral 8x7B** | Large batch processing | Very Fast | ⭐⭐⭐ |
+            
+            ### 📝 Template Guide:
+            - **Clip-Ready Visual**: 15-30 words, focus on visual elements only
+            - **Standard Business**: 40-60 words, comprehensive directory descriptions
+            - **E-commerce Ready**: 30-50 words, optimized for online marketplaces
+            - **Custom Prompt**: Use your own instructions for specific needs
+            """)
+        
+        # Update model info when selection changes
+        def update_model_info(model_name):
+            config = MODEL_CONFIGS[model_name]
+            return f"ℹ️ **{config['description']}**\nRecommended temp: {config['default_temp']}"
+        
+        model_selector.change(
+            update_model_info,
+            inputs=[model_selector],
+            outputs=[model_info]
+        )
+        
+        # Show/hide custom prompt field
+        def toggle_custom_prompt(template):
+            return gr.update(visible=(template == "Custom Prompt"))
+        
+        prompt_template.change(
+            toggle_custom_prompt,
+            inputs=[prompt_template],
+            outputs=[custom_prompt]
+        )
+        
+        # Process button click
+        process_btn.click(
+            fn=process_csv_advanced,
+            inputs=[
+                files_input,
+                category_column,
+                model_selector,
+                prompt_template,
+                custom_prompt,
+                max_tokens,
+                temperature,
+                top_p,
+                output_format
+            ],
+            outputs=[status_output, files_output, results_preview]
+        )
+        
+        # Set initial model info
+        demo.load(
+            update_model_info,
+            inputs=[model_selector],
+            outputs=[model_info]
+        )
     
-    💡 **Tips for Best Results:**
-    - Use Temperature 0.2-0.4 for consistent, focused descriptions
-    - Use Temperature 0.6-0.8 for more creative variations
-    - Failed categories are marked clearly - you can reprocess them separately
-    - Zero GPU acceleration: Add @spaces.GPU decorator or enable in Space Settings
-    """)
+    return demo
 
 if __name__ == "__main__":
-    demo.launch()
+    demo = create_interface()
+    demo.launch()