Update app.py

app.py

@@ -7,35 +7,35 @@ import time
 from datetime import datetime
 import traceback
 
-# Model configurations with their strengths
+# Working model configurations - These are verified to work with HF Inference API
 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",
+    "GPT-OSS 20B (Reliable)": {
+        "model_id": "openai/gpt-oss-20b",
+        "description": "Your current model - reliable for structured output",
         "default_temp": 0.3,
+        "max_tokens": 256
+    },
+    "Mistral 7B Instruct (Fast)": {
+        "model_id": "mistralai/Mistral-7B-Instruct-v0.2",
+        "description": "Fast and efficient, good for large batches",
+        "default_temp": 0.4,
         "max_tokens": 300
     },
-    "Qwen 2.5 72B Instruct (Fast & Accurate)": {
-        "model_id": "Qwen/Qwen2.5-72B-Instruct",
-        "description": "Great balance of speed and quality",
+    "Zephyr 7B Beta (Quality)": {
+        "model_id": "HuggingFaceH4/zephyr-7b-beta",
+        "description": "Good balance of quality and speed",
         "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,
+    "OpenChat 3.5 (Creative)": {
+        "model_id": "openchat/openchat-3.5-0106",
+        "description": "More creative descriptions",
+        "default_temp": 0.5,
         "max_tokens": 300
     }
 }
 
-# Different system prompts for different description styles
+# Enhanced prompt templates for better clip-ready descriptions
 PROMPT_TEMPLATES = {
     "Clip-Ready Visual (15-30 words)": """You are an expert at writing ultra-concise, visual descriptions for CLIP models and image search.
 
@@ -47,14 +47,19 @@ For each business category, create a description that:
 5. Describes physical appearance, setting, or visual activity
 
 Examples:
-Category: "Car Rental"
+Category: "Car Rental For Self Driven"
 Description: "rental car with keys, parked at pickup location, clean interior visible, rental company signage"
 
-Category: "Yoga Classes"
-Description: "people in yoga poses on mats, stretching in studio with mirrors, instructor demonstrating position"
+Category: "Mehandi"
+Description: "henna artwork on hands, intricate patterns being applied, cones and design templates visible"
 
-IMPORTANT: Respond with ONLY a JSON object:
-{"Category": "category name", "Description": "visual description"}""",
+Category: "Photographer"
+Description: "person with camera shooting, tripods and lighting equipment, studio setup with backdrops"
+
+IMPORTANT: Respond with ONLY a JSON object in this exact format:
+{"Category": "category name", "Description": "visual description"}
+
+Do not include any other text, explanations, or markdown formatting.""",
 
     "Standard Business (40-60 words)": """You are creating professional business descriptions for directory listings.
 
@@ -63,140 +68,114 @@ Generate descriptions that:
 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
 
-Examples:
+Example format:
 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: "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."
 
 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.
+    "Your Original Prompt": """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.
 
-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
+IMPORTANT: You must respond with ONLY a valid JSON object in this exact format:
+{"Category": "category name", "Description": "description text"}
 
-IMPORTANT: Respond with ONLY a JSON object:
-{"Category": "category name", "Description": "description text"}""",
-
-    "Custom Prompt": ""  # Will be filled by user
+Do not include any other text, explanations, or markdown formatting. Only output the JSON object."""
 }
 
-class EnhancedDescriptionGenerator:
-    def __init__(self):
-        self.clients = {}
-        self.initialize_clients()
+def extract_json_from_response(response_text):
+    """Enhanced JSON extraction with better error handling"""
+    if not response_text:
+        raise ValueError("Empty response")
     
-    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
+    response_text = response_text.strip()
     
-    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
-        
+    # 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()
+    
+    # Find 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:
         # Try to parse JSON
+        parsed = json.loads(json_str)
+    except json.JSONDecodeError as e:
+        # Try to fix common issues
+        json_str = json_str.replace("'", '"')
+        json_str = json_str.replace("\n", " ")
+        json_str = json_str.replace("\t", " ")
+        
+        # Try again
         try:
             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()
+        except:
+            # Last resort - try to extract description from raw text
+            if "description" in response_text.lower():
+                # Try to find the description part
+                lines = response_text.split('\n')
+                for line in lines:
+                    if 'description' in line.lower() and ':' in line:
+                        desc = line.split(':', 1)[1].strip().strip('"').strip("'")
+                        if len(desc) > 10:
+                            return desc
+            raise ValueError(f"Cannot parse JSON: {str(e)}")
     
-    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]
+    # Extract description
+    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()
+
+def process_single_category_with_fallback(
+    category, 
+    model_name, 
+    prompt_template,
+    max_tokens, 
+    temperature, 
+    top_p,
+    hf_token,
+    retry_count=3
+):
+    """Process with fallback to working model if primary fails"""
+    
+    # Try primary model
+    try:
+        client = InferenceClient(
+            token=hf_token,
+            model=MODEL_CONFIGS[model_name]["model_id"]
+        )
         
+        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 = ""
+                
+                # Try streaming
                 for message in client.chat_completion(
                     messages,
                     max_tokens=max_tokens,
@@ -212,55 +191,81 @@ class EnhancedDescriptionGenerator:
                     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")
+                    raise ValueError("Empty response")
                 
-                # Extract description
-                description = self.extract_json_from_response(response_text)
+                description = extract_json_from_response(response_text)
+                return response_text.strip(), description, model_name
                 
-                # Count words for validation
-                word_count = len(description.split())
+            except Exception as e:
+                if attempt == retry_count - 1:
+                    raise e
+                    
+    except Exception as primary_error:
+        # Fallback to GPT-OSS-20B which we know works
+        if model_name != "GPT-OSS 20B (Reliable)":
+            try:
+                print(f"Primary model failed, falling back to GPT-OSS-20B: {str(primary_error)[:100]}")
                 
-                return response_text.strip(), description, word_count
+                client = InferenceClient(
+                    token=hf_token,
+                    model="openai/gpt-oss-20b"
+                )
                 
-            except Exception as e:
-                last_error = f"Attempt {attempt + 1}/{retry_count}: {str(e)}"
+                system_prompt = PROMPT_TEMPLATES[prompt_template]
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"Category: \"{category}\""}
+                ]
                 
-                # 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}")
+                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
+                
+                if response_text:
+                    description = extract_json_from_response(response_text)
+                    return response_text.strip(), description, "GPT-OSS-20B (Fallback)"
+                    
+            except Exception as fallback_error:
+                raise Exception(f"Both primary and fallback failed. Primary: {str(primary_error)[:100]}, Fallback: {str(fallback_error)[:100]}")
+        else:
+            raise primary_error
 
-def process_csv_advanced(
+def process_csv_enhanced(
     files,
     category_column,
     model_name,
     prompt_template,
-    custom_prompt,
     max_tokens,
     temperature,
     top_p,
     output_format,
     progress=gr.Progress()
 ):
-    """Enhanced CSV processing with multiple models and output formats"""
+    """Enhanced processing with better error messages and fallbacks"""
     
     if not files or len(files) == 0:
         return "Please upload at least one CSV file.", None, None
     
-    # Check for HF token
+    # Get 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.", None, None
     
-    # Initialize generator
-    try:
-        generator = EnhancedDescriptionGenerator()
-    except Exception as e:
-        return f"Error initializing models: {str(e)}", None, None
+    if not hf_token:
+        return """⚠️ Error: HF_TOKEN not found. Please add your Hugging Face token as a Space Secret.
+        
+Go to: Space Settings → Secrets → Add 'HF_TOKEN'""", None, None
     
     all_results = []
     status_messages = []
@@ -273,12 +278,13 @@ def process_csv_advanced(
             file_name = os.path.basename(file.name)
             status_messages.append(f"📄 Processing file {file_idx + 1}/{len(files)}: {file_name}")
             
-            # Check column exists
+            # Check column
             if category_column not in df.columns:
-                status_messages.append(f"⚠️ Column '{category_column}' not found in {file_name}. Available: {', '.join(df.columns)}")
+                available_cols = ', '.join(df.columns[:5])
+                status_messages.append(f"⚠️ Column '{category_column}' not found. Available: {available_cols}")
                 continue
             
-            # Process categories
+            # Get unique categories
             categories = df[category_column].dropna().unique()
             total_categories = len(categories)
             
@@ -287,63 +293,65 @@ def process_csv_advanced(
             for idx, category in enumerate(categories):
                 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]}..."
+                    desc=f"Processing: {category[:30]}..."
                 )
                 
                 try:
-                    raw_response, description, word_count = generator.process_single_category(
+                    raw_response, description, used_model = process_single_category_with_fallback(
                         category,
                         model_name,
                         prompt_template,
-                        custom_prompt,
                         max_tokens,
                         temperature,
-                        top_p
+                        top_p,
+                        hf_token
                     )
                     
                     result = {
-                        "File": file_name,
                         "Category": category,
                         "Description": description,
-                        "Word_Count": word_count,
-                        "Model": model_name,
-                        "Prompt_Type": prompt_template,
+                        "Word_Count": len(description.split()),
+                        "Model_Used": used_model,
                         "Raw_Response": raw_response,
                         "Status": "Success"
                     }
                     
                     file_results.append(result)
                     all_results.append(result)
-                    status_messages.append(f"✅ {category[:30]}... ({word_count} words)")
+                    status_messages.append(f"✅ {category[:30]}... ({len(description.split())} words)")
                     
                 except Exception as e:
-                    error_msg = str(e)[:100]
+                    error_msg = str(e)
+                    if "Request ID" in error_msg:
+                        error_msg = "API Error - Try lowering temperature or using GPT-OSS model"
+                    
                     result = {
-                        "File": file_name,
                         "Category": category,
-                        "Description": f"[FAILED: {error_msg}]",
+                        "Description": f"[FAILED: {error_msg[:100]}]",
                         "Word_Count": 0,
-                        "Model": model_name,
-                        "Prompt_Type": prompt_template,
+                        "Model_Used": model_name,
                         "Raw_Response": "",
-                        "Status": f"Failed: {error_msg}"
+                        "Status": f"Failed"
                     }
                     
                     file_results.append(result)
                     all_results.append(result)
-                    status_messages.append(f"❌ {category[:30]}... - {error_msg}")
+                    status_messages.append(f"❌ {category[:30]}... - {error_msg[:50]}")
                 
                 # Rate limiting
-                time.sleep(0.3)
+                time.sleep(0.5)
             
-            # Create output file for this CSV
+            # Save output files
             if file_results:
                 timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                 base_name = os.path.splitext(file_name)[0]
                 
+                # Create DataFrame
+                output_df = pd.DataFrame(file_results)
+                
                 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_df.to_csv(csv_filename, index=False)
                     output_files.append(csv_filename)
                 
                 if output_format in ["JSON", "Both"]:
@@ -352,239 +360,173 @@ def process_csv_advanced(
                         json.dump(file_results, f, indent=2)
                     output_files.append(json_filename)
             
-            # Summary for this file
+            # Summary
             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"""
 📊 {file_name} Summary:
    - Total: {len(file_results)} categories
-   - Success: {success_count} ({success_count/len(file_results)*100:.1f}%)
+   - Success: {success_count} ({success_count/max(len(file_results),1)*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_messages.append(f"❌ Error processing {file_name}: {str(e)}")
     
-    # Overall summary
+    # Create 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}
+        summary = f"""## 🎯 Processing Complete!
 
-### Overall Statistics:
-- **Total Categories Processed:** {len(all_results)}
+### Statistics:
+- **Total Processed:** {len(all_results)} categories
 - **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}
+- **Failed:** {total_failed}
 
-### File Processing Log:
+### Details:
 """
         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)
+        # Create preview DataFrame
+        preview_df = pd.DataFrame(all_results)[['Category', 'Description', 'Word_Count', 'Status']][:20]
         
-        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
+        return status_text, output_files, preview_df
     else:
-        return "\n".join(status_messages) + "\n\n⚠️ No categories were processed successfully.", None, None
+        return "\n".join(status_messages), 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")
+# Create Gradio interface
+with gr.Blocks(title="Multi-Model Business Description Generator", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🚀 Multi-Model Business Description Generator
+    
+    Generate CLIP-ready visual descriptions using multiple AI models.
+    
+    ### Features:
+    - 🤖 **4 Different Models** - Choose the best for your needs
+    - 📝 **3 Prompt Templates** - Optimized for different use cases  
+    - 🔄 **Automatic Fallback** - Falls back to GPT-OSS if primary model fails
+    - 💾 **CSV & JSON Export** - Multiple output formats
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📤 Input")
             
-            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_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 name containing categories"
+            )
+            
+            gr.Markdown("### 🤖 Model Configuration")
+            
+            model_selector = gr.Dropdown(
+                label="Select Model",
+                choices=list(MODEL_CONFIGS.keys()),
+                value="GPT-OSS 20B (Reliable)",
+                info="GPT-OSS is most reliable, others may require fallback"
+            )
+            
+            prompt_template = gr.Dropdown(
+                label="Prompt Template",
+                choices=list(PROMPT_TEMPLATES.keys()),
+                value="Your Original Prompt",
+                info="Choose based on desired output style"
+            )
+            
+            gr.Markdown("### ⚙️ Settings")
+            
+            with gr.Row():
+                temperature = gr.Slider(
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=0.3,
+                    step=0.05,
+                    label="Temperature",
+                    info="Lower = consistent"
                 )
                 
-                files_output = gr.File(
-                    label="📥 Download Output Files",
-                    file_count="multiple"
+                top_p = gr.Slider(
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=0.9,
+                    step=0.05,
+                    label="Top-p"
                 )
-        
-        with gr.Row():
-            gr.Markdown("""
-            ### 💡 Model Recommendations:
             
-            | 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 | ⭐⭐⭐ |
+            max_tokens = gr.Slider(
+                minimum=64,
+                maximum=512,
+                value=256,
+                step=16,
+                label="Max Tokens"
+            )
             
-            ### 📝 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]
-        )
+            output_format = gr.Radio(
+                label="Output Format",
+                choices=["CSV", "JSON", "Both"],
+                value="CSV"
+            )
+            
+            process_btn = gr.Button("🚀 Generate Descriptions", variant="primary", size="lg")
         
-        # 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]
-        )
+        with gr.Column(scale=2):
+            gr.Markdown("### 📊 Results")
+            
+            status_output = gr.Markdown(
+                value="Results will appear here...",
+                label="Status"
+            )
+            
+            results_preview = gr.Dataframe(
+                label="Preview (First 20 Results)",
+                headers=["Category", "Description", "Word_Count", "Status"],
+                wrap=True
+            )
+            
+            files_output = gr.File(
+                label="📥 Download Output Files",
+                file_count="multiple"
+            )
+    
+    with gr.Row():
+        gr.Markdown("""
+        ### 💡 Tips:
+        - **GPT-OSS 20B** is the most reliable model
+        - Use **Temperature 0.2-0.4** for consistent results
+        - **Clip-Ready** template gives 15-30 word descriptions
+        - If a model fails, it automatically falls back to GPT-OSS
         
-        # Set initial model info
-        demo.load(
-            update_model_info,
-            inputs=[model_selector],
-            outputs=[model_info]
-        )
+        ### ⚠️ Troubleshooting:
+        - **API Errors**: Try using GPT-OSS 20B model
+        - **Failed Categories**: Lower temperature to 0.2
+        - **Empty Responses**: Check your HF_TOKEN is valid
+        """)
     
-    return demo
+    # Process button
+    process_btn.click(
+        fn=process_csv_enhanced,
+        inputs=[
+            files_input,
+            category_column,
+            model_selector,
+            prompt_template,
+            max_tokens,
+            temperature,
+            top_p,
+            output_format
+        ],
+        outputs=[status_output, files_output, results_preview]
+    )
 
 if __name__ == "__main__":
-    demo = create_interface()
     demo.launch()