Upload app.py

app.py

@@ -0,0 +1,1057 @@
+import gradio as gr
+import os
+from pathlib import Path
+from pinecone import Pinecone
+from typing import List, Tuple
+import tempfile
+import shutil
+from dotenv import load_dotenv
+import time
+from datetime import datetime
+import json
+
+# Load environment variables
+load_dotenv()
+
+# Authentication configuration
+AUTH_PASSWORD = "gst_litigation@34$$&"
+
+def authenticate(password):
+    """Simple authentication function"""
+    return password == AUTH_PASSWORD
+
+# Validate required environment variables
+required_env_vars = ["PINECONE_API_KEY"]
+missing_vars = [var for var in required_env_vars if not os.getenv(var)]
+
+if missing_vars:
+    raise ValueError(f"Missing required environment variables: {', '.join(missing_vars)}")
+
+# Initialize Pinecone
+pinecone_api_key = os.getenv("PINECONE_API_KEY")
+pc = Pinecone(api_key=pinecone_api_key)
+
+# Create uploads directory
+UPLOAD_FOLDER = "uploads"
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+def parse_pinecone_timestamp(iso_string):
+    """
+    Parses an ISO 8601 string from Pinecone, handling nanosecond precision.
+    
+    Args:
+        iso_string (str): The ISO-formatted timestamp string.
+        
+    Returns:
+        datetime: The parsed datetime object.
+    """
+    if not isinstance(iso_string, str) or not iso_string:
+        return datetime.min # Return a very old date for sorting purposes
+
+    # Handle ISO strings ending with 'Z' (convert to +00:00)
+    if iso_string.endswith('Z'):
+        iso_string = iso_string[:-1] + '+00:00'
+    
+    # Find the decimal point for fractional seconds
+    decimal_point = iso_string.find('.')
+    
+    if decimal_point != -1:
+        # Find where the timezone info starts (+ or -)
+        tz_start = max(iso_string.rfind('+'), iso_string.rfind('-'))
+        
+        if tz_start > decimal_point:
+            # Extract the fractional seconds part
+            fractional_part = iso_string[decimal_point+1:tz_start]
+            
+            # Truncate to 6 digits (microseconds) if longer
+            if len(fractional_part) > 6:
+                fractional_part = fractional_part[:6]
+            
+            # Reconstruct the ISO string with truncated fractional seconds
+            iso_string = iso_string[:decimal_point+1] + fractional_part + iso_string[tz_start:]
+    
+    return datetime.fromisoformat(iso_string)
+
+def get_all_files():
+    """Get all files from Pinecone Assistant and sort them"""
+    try:
+        assistant_name = os.getenv("PINECONE_ASSISTANT_NAME", "freeplan")
+        assistant = pc.assistant.Assistant(assistant_name=assistant_name)
+        
+        # List all files in the assistant
+        files_response = assistant.list_files()
+        
+        # Check if files_response is directly a list or has a files attribute
+        if hasattr(files_response, 'files'):
+            files_list = files_response.files
+        else:
+            files_list = files_response
+        
+        if not files_list:
+            return []
+        
+        # Sort files by creation time (most recent first) using robust timestamp parsing
+        sorted_files = sorted(
+            files_list, 
+            key=lambda x: parse_pinecone_timestamp(getattr(x, 'created_on', '')), 
+            reverse=True
+        )
+        
+        return sorted_files
+        
+    except Exception as e:
+        return []
+
+def get_file_choices():
+    """Get file choices for the dropdown - returns list of (title, file_id) tuples"""
+    try:
+        all_files = get_all_files()
+        if not all_files:
+            return []
+        
+        choices = []
+        for file_obj in all_files:
+            file_name = getattr(file_obj, 'name', 'Unknown File')
+            file_id = getattr(file_obj, 'id', 'unknown')
+            created_on = getattr(file_obj, 'created_on', '')
+            
+            # Format timestamp for display
+            try:
+                if created_on:
+                    created_formatted = parse_pinecone_timestamp(created_on).strftime('%Y-%m-%d %H:%M')
+                    display_name = f"{file_name} (uploaded: {created_formatted})"
+                else:
+                    display_name = file_name
+            except:
+                display_name = file_name
+            
+            choices.append((display_name, file_id))
+        
+        return choices
+    except Exception as e:
+        return []
+
+def refresh_delete_dropdown():
+    """Refresh the dropdown with current files"""
+    choices = get_file_choices()
+    if not choices:
+        return gr.update(choices=[], value=None, interactive=False)
+    return gr.update(choices=choices, value=None, interactive=True)
+
+def delete_selected_files(selected_file_ids, progress=gr.Progress()):
+    """Delete multiple selected files by their IDs"""
+    if not selected_file_ids:
+        return "❌ **Error:** No files selected for deletion", ""
+    
+    try:
+        progress(0.1, desc="🔧 Initializing Pinecone Assistant...")
+        assistant_name = os.getenv("PINECONE_ASSISTANT_NAME", "freeplan")
+        assistant = pc.assistant.Assistant(assistant_name=assistant_name)
+        
+        # Get current files to map IDs to names
+        all_files = get_all_files()
+        file_id_to_name = {getattr(f, 'id', ''): getattr(f, 'name', 'Unknown') for f in all_files}
+        
+        total_files = len(selected_file_ids)
+        deleted_files = []
+        failed_files = []
+        
+        progress(0.2, desc=f"🗑️ Starting deletion of {total_files} files...")
+        
+        for i, file_id in enumerate(selected_file_ids):
+            try:
+                file_name = file_id_to_name.get(file_id, f"File ID: {file_id}")
+                progress((0.2 + (i / total_files) * 0.7), desc=f"🗑️ Deleting: {file_name}...")
+                
+                # Delete the file
+                response = assistant.delete_file(file_id=file_id)
+                deleted_files.append({
+                    'name': file_name,
+                    'id': file_id,
+                    'status': 'success'
+                })
+                
+                time.sleep(0.2)  # Small delay between deletions
+                
+            except Exception as delete_error:
+                failed_files.append({
+                    'name': file_id_to_name.get(file_id, f"File ID: {file_id}"),
+                    'id': file_id,
+                    'error': str(delete_error)
+                })
+        
+        progress(1.0, desc="✅ Deletion process completed!")
+        
+        # Format results
+        success_count = len(deleted_files)
+        error_count = len(failed_files)
+        
+        status_message = f"📊 **Deletion Complete**\n\n"
+        status_message += f"✅ **Successfully deleted:** {success_count} files\n"
+        status_message += f"❌ **Failed to delete:** {error_count} files\n"
+        status_message += f"📁 **Total processed:** {total_files} files\n\n"
+        
+        # Detailed results
+        detailed_results = "## 🗑️ **Deletion Results**\n\n"
+        
+        if deleted_files:
+            detailed_results += "### ✅ **Successfully Deleted Files:**\n"
+            for file_info in deleted_files:
+                detailed_results += f"- **{file_info['name']}** (`{file_info['id']}`)\n"
+            detailed_results += "\n"
+        
+        if failed_files:
+            detailed_results += "### ❌ **Failed Deletions:**\n"
+            for file_info in failed_files:
+                detailed_results += f"- **{file_info['name']}** (`{file_info['id']}`)\n"
+                detailed_results += f"  - Error: {file_info['error']}\n"
+            detailed_results += "\n"
+        
+        return status_message, detailed_results
+        
+    except Exception as e:
+        error_msg = f"❌ **Critical Error during deletion:** {str(e)}"
+        return error_msg, ""
+
+def list_uploaded_files_paginated(page_num=0, progress=gr.Progress()):
+    """List files with pagination - 100 files per page"""
+    try:
+        progress(0.1, desc="🔍 Getting files...")
+        
+        # Get all files
+        all_files = get_all_files()
+        
+        if not all_files:
+            progress(1.0, desc="✅ Complete - No files found")
+            return "📋 **No files found in Pinecone Assistant**", "", "No files available", gr.update(visible=False), gr.update(visible=False)
+        
+        progress(0.5, desc="📊 Processing page...")
+        
+        # Pagination settings
+        files_per_page = 100
+        start_idx = page_num * files_per_page
+        end_idx = start_idx + files_per_page
+        
+        # Get files for current page
+        page_files = all_files[start_idx:end_idx]
+        total_files = len(all_files)
+        total_pages = (total_files + files_per_page - 1) // files_per_page
+        
+        # Create summary
+        summary = f"📊 **Files Summary (Page {page_num + 1} of {total_pages})**\n\n"
+        summary += f"📁 **Total files:** {total_files}\n"
+        summary += f"📋 **Showing:** {start_idx + 1}-{min(end_idx, total_files)} of {total_files}\n\n"
+        
+        # Create file list - ONLY TITLES, VERTICALLY
+        detailed_info = f"## 📋 **Latest Uploaded Files - Page {page_num + 1}**\n\n"
+        
+        progress(0.8, desc="📝 Formatting file titles...")
+        
+        for i, file_obj in enumerate(page_files, 1):
+            try:
+                # Get only the file name/title
+                file_name = getattr(file_obj, 'name', 'Unknown File')
+                file_id = getattr(file_obj, 'id', 'Unknown ID')
+                created_on = getattr(file_obj, 'created_on', '')
+                
+                global_index = start_idx + i
+                
+                # Format timestamp
+                try:
+                    if created_on:
+                        created_formatted = parse_pinecone_timestamp(created_on).strftime('%Y-%m-%d %H:%M')
+                    else:
+                        created_formatted = 'Unknown'
+                except:
+                    created_formatted = 'Unknown'
+                
+                # Display file info
+                detailed_info += f"{global_index}. **{file_name}**\n"
+                detailed_info += f"   📅 Uploaded: {created_formatted} | 🆔 ID: `{file_id}`\n\n"
+                
+            except Exception as file_error:
+                detailed_info += f"{start_idx + i}. ❌ **Error loading file**\n\n"
+        
+        # Pagination info
+        pagination_info = f"📄 Page {page_num + 1} of {total_pages} | Total: {total_files} files"
+        
+        # Show/hide next/prev buttons
+        show_prev = page_num > 0
+        show_next = page_num < total_pages - 1
+        
+        progress(1.0, desc="✅ Page loaded successfully!")
+        
+        return summary, detailed_info, pagination_info, gr.update(visible=show_prev), gr.update(visible=show_next)
+        
+    except Exception as e:
+        error_msg = f"❌ **Error retrieving file list:** {str(e)}"
+        return error_msg, "", "Error", gr.update(visible=False), gr.update(visible=False)
+
+def load_next_page(current_page_info):
+    """Load next page of files"""
+    try:
+        # Extract current page number from pagination info
+        current_page = int(current_page_info.split("Page ")[1].split(" of")[0]) - 1
+        return list_uploaded_files_paginated(current_page + 1)
+    except:
+        return list_uploaded_files_paginated(0)
+
+def load_prev_page(current_page_info):
+    """Load previous page of files"""
+    try:
+        # Extract current page number from pagination info
+        current_page = int(current_page_info.split("Page ")[1].split(" of")[0]) - 1
+        return list_uploaded_files_paginated(max(0, current_page - 1))
+    except:
+        return list_uploaded_files_paginated(0)
+
+def refresh_file_list():
+    """Refresh the file list"""
+    return "🔄 **Refreshing file list... Please wait**"
+
+def process_files_with_progress(files, *metadata_inputs, progress=gr.Progress()):
+    """Process multiple files with individual metadata and show progress"""
+    if not files:
+        return "❌ Error: No files selected", ""
+    
+    if len(files) > 10:
+        return "❌ Error: Maximum 10 files allowed at a time", ""
+    
+    try:
+        results = []
+        errors = []
+        total_files = len(files)
+        
+        # Initialize Pinecone Assistant
+        progress(0, desc="🔧 Initializing Pinecone Assistant...")
+        time.sleep(0.5)  # Small delay to show the progress
+        assistant_name = os.getenv("PINECONE_ASSISTANT_NAME", "freeplan")
+        assistant = pc.assistant.Assistant(assistant_name=assistant_name)
+
+        # Process each file with its individual metadata
+        for i, file_path in enumerate(files):
+            try:
+                filename = os.path.basename(file_path)
+                progress((i / total_files), desc=f"📄 Processing {filename}... ({i+1}/{total_files})")
+                
+                # Get metadata for this specific file (3 fields per file: sections, keywords, description)
+                sections_idx = i * 3
+                keywords_idx = i * 3 + 1
+                description_idx = i * 3 + 2
+                
+                if sections_idx < len(metadata_inputs):
+                    sections = metadata_inputs[sections_idx] or ""
+                    keywords = metadata_inputs[keywords_idx] or ""
+                    description = metadata_inputs[description_idx] or ""
+                else:
+                    sections = keywords = description = ""
+                
+                # Skip if no metadata provided for this file
+                if not sections.strip() and not keywords.strip() and not description.strip():
+                    errors.append({
+                        "filename": filename,
+                        "error": "❌ Error: No metadata provided"
+                    })
+                    continue
+                
+                # Prepare metadata for this file
+                progress((i / total_files), desc=f"🏷️ Preparing metadata for {filename}...")
+                metadata = {
+                    "sections": [s.strip() for s in sections.split(",") if s.strip()],
+                    "keywords": [k.strip() for k in keywords.split(",") if k.strip()],
+                    "description": description.strip()
+                }
+                
+                # Copy to uploads directory
+                progress((i / total_files), desc=f"📁 Copying {filename} to uploads...")
+                destination_path = os.path.join(UPLOAD_FOLDER, filename)
+                shutil.copy2(file_path, destination_path)
+
+                # Upload to Pinecone Assistant
+                progress((i / total_files), desc=f"☁️ Uploading {filename} to Pinecone...")
+                response = assistant.upload_file(
+                    file_path=destination_path, 
+                    metadata=metadata, 
+                    timeout=None
+                )
+
+                results.append({
+                    "filename": filename,
+                    "status": "✅ Success",
+                    "metadata": metadata,
+                    "response": str(response)
+                })
+
+            except Exception as file_error:
+                errors.append({
+                    "filename": os.path.basename(file_path),
+                    "error": f"❌ Error: {str(file_error)}"
+                })
+
+        # Final progress update
+        progress(1.0, desc="✅ Processing complete!")
+        time.sleep(0.5)
+
+        # Format results for display
+        success_count = len(results)
+        error_count = len(errors)
+        
+        status_message = f"📊 **Processing Complete**\n\n"
+        status_message += f"✅ **Successful uploads:** {success_count}\n"
+        status_message += f"❌ **Failed uploads:** {error_count}\n"
+        status_message += f"📁 **Total files processed:** {len(files)}\n\n"
+        
+        # Detailed results
+        detailed_results = "## 📋 **Detailed Results**\n\n"
+        
+        if results:
+            detailed_results += "### ✅ **Successful Uploads:**\n"
+            for result in results:
+                detailed_results += f"- **{result['filename']}**\n"
+                detailed_results += f"  - Sections: {', '.join(result['metadata']['sections'])}\n"
+                detailed_results += f"  - Keywords: {', '.join(result['metadata']['keywords'])}\n"
+                detailed_results += f"  - Description: {result['metadata']['description']}\n\n"
+        
+        if errors:
+            detailed_results += "### ❌ **Failed Uploads:**\n"
+            for error in errors:
+                detailed_results += f"- **{error['filename']}** - {error['error']}\n"
+        
+        return status_message, detailed_results, "✅ **Processing completed successfully!**"
+    
+    except Exception as e:
+        error_msg = f"❌ **Critical Error:** {str(e)}"
+        return error_msg, "", "❌ **Processing failed with error**"
+
+def update_metadata_fields(files):
+    """Update metadata fields based on uploaded files"""
+    if not files:
+        return [gr.update(visible=False)] * 30  # Hide all fields
+    
+    if len(files) > 10:
+        # Show error and hide all fields
+        return [gr.update(visible=False)] * 30
+    
+    updates = []
+    for i in range(len(files)):
+        if i < len(files):
+            filename = os.path.basename(files[i])
+            # Show 3 fields per file (sections, keywords, description)
+            updates.extend([
+                gr.update(visible=True, label=f"📑 Sections for {filename}", placeholder="e.g., Case Summary, Evidence, Legal Arguments"),
+                gr.update(visible=True, label=f"🔍 Keywords for {filename}", placeholder="e.g., litigation, court, plaintiff, defendant"),
+                gr.update(visible=True, label=f"📝 Description for {filename}", placeholder="Brief description of this document")
+            ])
+        
+    # Hide remaining fields
+    while len(updates) < 30:
+        updates.append(gr.update(visible=False))
+    
+    return updates[:30]
+
+def clear_form():
+    """Clear all form fields"""
+    return [None] + [""] * 30 + ["", "", "🟢 **Ready to process documents**"]
+
+def clear_delete_form():
+    """Clear delete form"""
+    return gr.update(value=[]), "", ""
+
+def start_processing():
+    """Show processing started status"""
+    return "🔄 **Processing documents... Please wait**"
+
+def finish_processing():
+    """Show processing finished status"""
+    return "✅ **Processing completed successfully!**"
+
+def create_main_interface():
+    """Create the main application interface"""
+    with gr.Blocks(
+        title="📄 LITIGATION RESEARCH DOC SYSTEM",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 1400px !important;
+            margin: auto;
+        }
+        .upload-container {
+            border: 2px dashed #4CAF50;
+            border-radius: 10px;
+            padding: 20px;
+            text-align: center;
+            background-color: #f8f9fa;
+        }
+        .delete-container {
+            border: 2px dashed #f44336;
+            border-radius: 10px;
+            padding: 20px;
+            background-color: #ffebee;
+        }
+        .tab-nav {
+            margin-bottom: 20px;
+        }
+        """
+    ) as app:
+        
+        gr.Markdown(
+            """
+            # 📄 LITIGATION RESEARCH DOC SYSTEM
+            
+            Upload, manage, and delete documents in the Pinecone Assistant for litigation research processing.
+            
+            ## 🚀 Features:
+            - ✅ **Multiple file upload** - Select and upload multiple documents at once
+            - 🏷️ **Metadata tagging** - Add sections, keywords, and descriptions
+            - 🔄 **Batch processing** - All files processed with individual metadata
+            - 🗑️ **File deletion** - Delete multiple files by selecting from dropdown
+            - 📊 **File management** - View uploaded files with timestamps and metadata
+            - 📋 **Detailed reporting** - See success/failure status for each operation
+            
+            ---
+            """
+        )
+        
+        # Create tabs for different functionalities
+        with gr.Tabs() as tabs:
+            
+            # Tab 1: Upload Documents
+            with gr.TabItem("📤 Upload Documents", id="upload_tab"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📁 **File Upload**")
+                        files_input = gr.File(
+                            label="Select Documents (Max 10 files)",
+                            file_count="multiple",
+                            file_types=[".pdf", ".doc", ".docx", ".txt"],
+                            elem_classes=["upload-container"]
+                        )
+                        
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 🏷️ **Document Metadata (Individual for Each File)**")
+                        gr.Markdown("*Upload files first, then metadata fields will appear for each document*")
+                
+                # Dynamic metadata fields container
+                with gr.Column() as metadata_container:
+                    # Create 30 text fields (enough for 10 files with 3 fields each)
+                    metadata_fields = []
+                    for i in range(30):
+                        field = gr.Textbox(
+                            label=f"Field {i}",
+                            placeholder="",
+                            visible=False,
+                            lines=2
+                        )
+                        metadata_fields.append(field)
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        upload_btn = gr.Button(
+                            "🚀 Upload Documents to Pinecone Assistant",
+                            variant="primary",
+                            size="lg"
+                        )
+                        
+                    with gr.Column(scale=1):
+                        clear_btn = gr.Button(
+                            "🗑️ Clear Form",
+                            variant="secondary",
+                            size="lg"
+                        )
+                
+                # Processing status indicator
+                with gr.Row():
+                    processing_status = gr.Markdown(
+                        value="🟢 **Ready to process documents**",
+                        visible=True
+                    )
+                
+                gr.Markdown("---")
+                
+                # Results section
+                with gr.Row():
+                    with gr.Column():
+                        status_output = gr.Markdown(
+                            label="📊 Upload Status",
+                            value="*Ready to upload documents...*"
+                        )
+                
+                with gr.Row():
+                    with gr.Column():
+                        results_output = gr.Markdown(
+                            label="📋 Detailed Results",
+                            value="",
+                            max_height=400  # Add height limit for scrolling
+                        )
+
+            # Tab 2: Delete Documents
+            with gr.TabItem("🗑️ Delete Documents", id="delete_tab"):
+                gr.Markdown("### 🗑️ **Delete Multiple Documents**")
+                gr.Markdown("Select multiple files from the dropdown to delete them from the Pinecone Assistant.")
+                
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        file_dropdown = gr.Dropdown(
+                            label="📋 Select Files to Delete (Multiple Selection)",
+                            choices=[],
+                            multiselect=True,
+                            interactive=False,
+                            elem_classes=["delete-container"]
+                        )
+                        
+                    with gr.Column(scale=1):
+                        refresh_dropdown_btn = gr.Button(
+                            "🔄 Refresh File List",
+                            variant="secondary",
+                            size="lg"
+                        )
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        delete_btn = gr.Button(
+                            "🗑️ Delete Selected Files",
+                            variant="stop",
+                            size="lg"
+                        )
+                        
+                    with gr.Column(scale=1):
+                        clear_delete_btn = gr.Button(
+                            "↺ Clear Selection",
+                            variant="secondary",
+                            size="lg"
+                        )
+                
+                gr.Markdown("---")
+                
+                # Delete results section
+                with gr.Row():
+                    with gr.Column():
+                        delete_status_output = gr.Markdown(
+                            label="📊 Deletion Status",
+                            value="*Select files to delete...*"
+                        )
+                
+                with gr.Row():
+                    with gr.Column():
+                        delete_results_output = gr.Markdown(
+                            label="🗑️ Deletion Results",
+                            value="",
+                            max_height=400
+                        )
+            
+            # Tab 3: View Uploaded Files
+            with gr.TabItem("📋 View Uploaded Files", id="view_tab"):
+                gr.Markdown("### 📋 **Uploaded Files Management**")
+                gr.Markdown("View all files currently uploaded to the Pinecone Assistant with their metadata and timestamps.")
+                
+                with gr.Row():
+                    refresh_btn = gr.Button(
+                        "🔄 Fetch Files",
+                        variant="primary",
+                        size="lg"
+                    )
+                
+                # File list status
+                with gr.Row():
+                    file_list_status = gr.Markdown(
+                        value="🟡 **Click 'Fetch Files' to load uploaded files**",
+                        visible=True
+                    )
+                
+                gr.Markdown("---")
+                
+                # Pagination controls
+                with gr.Row():
+                    prev_btn = gr.Button(
+                        "⬅️ Previous 100",
+                        variant="secondary",
+                        visible=False
+                    )
+                    pagination_info = gr.Markdown(
+                        value="📄 Page 1 of 1 | Total: 0 files",
+                        elem_classes=["pagination-info"]
+                    )
+                    next_btn = gr.Button(
+                        "Next 100 ➡️",
+                        variant="secondary", 
+                        visible=False
+                    )
+                
+                # File list results
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        file_summary = gr.Markdown(
+                            label="📊 Files Summary",
+                            value="*Click refresh to load file summary...*"
+                        )
+                
+                with gr.Row():
+                    with gr.Column():
+                        file_details = gr.Markdown(
+                            label="📋 File Details",
+                            value="*Click refresh to load file details...*",
+                            max_height=600  # Add height limit for scrolling
+                        )
+        
+        # Event handlers for Upload tab
+        
+        # Update metadata fields when files are uploaded
+        files_input.change(
+            fn=update_metadata_fields,
+            inputs=[files_input],
+            outputs=metadata_fields
+        )
+        
+        # Show processing status when upload starts
+        upload_btn.click(
+            fn=start_processing,
+            outputs=[processing_status]
+        ).then(
+            fn=process_files_with_progress,
+            inputs=[files_input] + metadata_fields,
+            outputs=[status_output, results_output, processing_status]
+        )
+        
+        clear_btn.click(
+            fn=clear_form,
+            outputs=[files_input] + metadata_fields + [status_output, results_output, processing_status]
+        )
+        
+        # Event handlers for Delete tab
+        
+        # Refresh dropdown with current files
+        refresh_dropdown_btn.click(
+            fn=refresh_delete_dropdown,
+            outputs=[file_dropdown]
+        )
+        
+        # Delete selected files
+        delete_btn.click(
+            fn=delete_selected_files,
+            inputs=[file_dropdown],
+            outputs=[delete_status_output, delete_results_output]
+        )
+        
+        # Clear delete form
+        clear_delete_btn.click(
+            fn=clear_delete_form,
+            outputs=[file_dropdown, delete_status_output, delete_results_output]
+        )
+        
+        # Event handlers for View Files tab
+        
+        # Fetch files - load page 1
+        refresh_btn.click(
+            fn=refresh_file_list,
+            outputs=[file_list_status]
+        ).then(
+            fn=list_uploaded_files_paginated,
+            inputs=[],
+            outputs=[file_summary, file_details, pagination_info, prev_btn, next_btn]
+        )
+        
+        # Next page button
+        next_btn.click(
+            fn=load_next_page,
+            inputs=[pagination_info],
+            outputs=[file_summary, file_details, pagination_info, prev_btn, next_btn]
+        )
+        
+        # Previous page button  
+        prev_btn.click(
+            fn=load_prev_page,
+            inputs=[pagination_info],
+            outputs=[file_summary, file_details, pagination_info, prev_btn, next_btn]
+        )
+        
+        # Footer
+        gr.Markdown(
+            """
+            ---
+            
+            ### 💡 **Usage Tips:**
+            
+            **Upload Documents:**
+            - Select up to 10 PDF, DOC, DOCX, or TXT files at once
+            - Upload files first, then fill individual metadata for each document
+            - Each file gets its own sections, keywords, and description
+            - Check the results section for upload status
+            
+            **Delete Documents:**
+            - Click 'Refresh File List' to load current files in dropdown
+            - Select multiple files using the dropdown (supports multi-select)
+            - Click 'Delete Selected Files' to remove them permanently
+            - View deletion results for success/failure status
+            
+            **View Uploaded Files:**
+            - Click 'Fetch Files' to see all uploaded files
+            - View file details including upload timestamps and metadata
+            - Files are sorted by most recent first
+            - Use pagination to navigate through large file lists
+            
+            ### ⚠️ **Important Notes:**
+            - File deletion is **permanent** and cannot be undone
+            - Always verify your selection before deleting files
+            - The system maps file titles to IDs internally for deletion
+            
+            ### 📞 **Support:**
+            For issues or questions, contact the development team.
+            """
+        )
+    
+    return app
+
+def create_login_interface():
+    """Create the login interface"""
+    with gr.Blocks(
+        title="🔐 Authentication Required",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 500px !important;
+            margin: auto;
+            padding-top: 100px;
+        }
+        .login-container {
+            border: 2px solid #2196F3;
+            border-radius: 15px;
+            padding: 30px;
+            text-align: center;
+            background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+            box-shadow: 0 10px 20px rgba(0,0,0,0.1);
+        }
+        .password-input {
+            margin: 20px 0;
+        }
+        .login-button {
+            margin-top: 15px;
+        }
+        .error-message {
+            color: #f44336;
+            font-weight: bold;
+            margin-top: 10px;
+        }
+        """
+    ) as login_app:
+        
+        with gr.Column(elem_classes=["login-container"]):
+            gr.Markdown(
+                """
+                # 🔐 **LITIGATION RESEARCH DOC SYSTEM**
+                ## **Authentication Required**
+                
+                Please enter the password to access the application.
+                
+                ---
+                """
+            )
+            
+            password_input = gr.Textbox(
+                label="🔑 Password",
+                type="password",
+                placeholder="Enter password to access the system",
+                elem_classes=["password-input"]
+            )
+            
+            login_btn = gr.Button(
+                "🚀 Login",
+                variant="primary",
+                size="lg",
+                elem_classes=["login-button"]
+            )
+            
+            error_message = gr.Markdown(
+                value="",
+                visible=False,
+                elem_classes=["error-message"]
+            )
+            
+            gr.Markdown(
+                """
+                ---
+                
+                ### 🛡️ **Security Notice:**
+                - This system contains sensitive litigation research documentation
+                - Authorized access only
+                - All activities are logged
+                
+                ### 📞 **Need Access?**
+                Contact your system administrator for credentials.
+                """
+            )
+    
+    return login_app, password_input, login_btn, error_message
+def main():
+    """Main application with authentication — single Gradio Blocks app.
+
+    This builds both the login UI and the main application UI inside one
+    `gr.Blocks` so we only call `.launch()` once. The main UI is hidden
+    until authentication succeeds. This avoids launching two separate
+    Gradio servers which was causing the server to close unexpectedly.
+    """
+
+    # Reuse same theme/CSS as main app for consistency
+    app_css = """
+        .gradio-container {
+            max-width: 1400px !important;
+            margin: auto;
+        }
+        .upload-container {
+            border: 2px dashed #4CAF50;
+            border-radius: 10px;
+            padding: 20px;
+            text-align: center;
+            background-color: #f8f9fa;
+        }
+        .delete-container {
+            border: 2px dashed #f44336;
+            border-radius: 10px;
+            padding: 20px;
+            background-color: #ffebee;
+        }
+        .login-container {
+            border: 2px solid #2196F3;
+            border-radius: 15px;
+            padding: 30px;
+            text-align: center;
+            background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+            box-shadow: 0 10px 20px rgba(0,0,0,0.1);
+        }
+    """
+
+    with gr.Blocks(title="LITIGATION RESEARCH DOC SYSTEM", theme=gr.themes.Soft(), css=app_css) as app:
+
+        # --- LOGIN CONTAINER (visible initially) ---
+        with gr.Column(elem_classes=["login-container"]) as login_container:
+            gr.Markdown("""
+            # LITIGATION RESEARCH DOC SYSTEM
+            Authentication required
+            """)
+
+            password_input = gr.Textbox(
+                label="Password",
+                type="password",
+                placeholder="Enter password"
+            )
+
+            login_btn = gr.Button("Login", variant="primary", size="lg")
+
+            error_message = gr.Markdown(value="", visible=False)
+
+        # --- MAIN APP CONTAINER (hidden until auth) ---
+        with gr.Column(visible=False) as main_container:
+            # Insert main UI contents (slimmed text, no emojis)
+            gr.Markdown(
+                """
+                # LITIGATION RESEARCH DOC SYSTEM
+
+                Upload, manage, and delete documents in the Pinecone Assistant.
+                """
+            )
+
+            with gr.Tabs() as tabs:
+                # Upload Tab
+                with gr.TabItem("Upload Documents", id="upload_tab"):
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            gr.Markdown("### File Upload")
+                            files_input = gr.File(
+                                label="Select Documents (Max 10 files)",
+                                file_count="multiple",
+                                file_types=[".pdf", ".doc", ".docx", ".txt"],
+                                elem_classes=["upload-container"]
+                            )
+                        with gr.Column(scale=1):
+                            gr.Markdown("### Document Metadata")
+
+                    with gr.Column() as metadata_container:
+                        metadata_fields = []
+                        for i in range(30):
+                            field = gr.Textbox(label=f"Field {i}", placeholder="", visible=False, lines=2)
+                            metadata_fields.append(field)
+
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            upload_btn = gr.Button("Upload Documents to Pinecone Assistant", variant="primary")
+                        with gr.Column(scale=1):
+                            clear_btn = gr.Button("Clear Form", variant="secondary")
+
+                    processing_status = gr.Markdown(value="Ready to process documents", visible=True)
+
+                    status_output = gr.Markdown(label="Upload Status", value="Ready to upload documents...")
+                    results_output = gr.Markdown(label="Detailed Results", value="", max_height=400)
+
+                # Delete Tab
+                with gr.TabItem("Delete Documents", id="delete_tab"):
+                    gr.Markdown("### Delete Documents")
+                    with gr.Row():
+                        with gr.Column(scale=2):
+                            file_dropdown = gr.Dropdown(label="Select Files to Delete", choices=[], multiselect=True, interactive=False, elem_classes=["delete-container"])
+                        with gr.Column(scale=1):
+                            refresh_dropdown_btn = gr.Button("Refresh File List", variant="secondary")
+
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            delete_btn = gr.Button("Delete Selected Files", variant="stop")
+                        with gr.Column(scale=1):
+                            clear_delete_btn = gr.Button("Clear Selection", variant="secondary")
+
+                    delete_status_output = gr.Markdown(label="Deletion Status", value="Select files to delete...")
+                    delete_results_output = gr.Markdown(label="Deletion Results", value="", max_height=400)
+
+                # View Tab
+                with gr.TabItem("View Uploaded Files", id="view_tab"):
+                    gr.Markdown("### Uploaded Files Management")
+                    with gr.Row():
+                        refresh_btn = gr.Button("Fetch Files", variant="primary")
+
+                    file_list_status = gr.Markdown(value="Click 'Fetch Files' to load uploaded files", visible=True)
+
+                    with gr.Row():
+                        prev_btn = gr.Button("Previous 100", variant="secondary", visible=False)
+                        pagination_info = gr.Markdown(value="Page 1 of 1 | Total: 0 files")
+                        next_btn = gr.Button("Next 100", variant="secondary", visible=False)
+
+                    file_summary = gr.Markdown(label="Files Summary", value="Click refresh to load file summary...")
+                    file_details = gr.Markdown(label="File Details", value="Click refresh to load file details...", max_height=600)
+
+        # --- EVENT HANDLERS ---
+        # Login handlers: show main_container on success, show error on failure
+        def handle_login(password):
+            if authenticate(password):
+                return gr.update(visible=False), gr.update(value="", visible=False), gr.update(visible=True)
+            else:
+                return gr.update(visible=True), gr.update(value="Invalid password. Please try again.", visible=True), gr.update(visible=False)
+
+        login_btn.click(fn=handle_login, inputs=[password_input], outputs=[login_container, error_message, main_container])
+        password_input.submit(fn=handle_login, inputs=[password_input], outputs=[login_container, error_message, main_container])
+
+        # Wiring existing handlers from earlier in the file
+        files_input.change(fn=update_metadata_fields, inputs=[files_input], outputs=metadata_fields)
+
+        upload_btn.click(fn=start_processing, outputs=[processing_status]).then(
+            fn=process_files_with_progress,
+            inputs=[files_input] + metadata_fields,
+            outputs=[status_output, results_output, processing_status]
+        )
+
+        clear_btn.click(fn=clear_form, outputs=[files_input] + metadata_fields + [status_output, results_output, processing_status])
+
+        refresh_dropdown_btn.click(fn=refresh_delete_dropdown, outputs=[file_dropdown])
+        delete_btn.click(fn=delete_selected_files, inputs=[file_dropdown], outputs=[delete_status_output, delete_results_output])
+        clear_delete_btn.click(fn=clear_delete_form, outputs=[file_dropdown, delete_status_output, delete_results_output])
+
+        refresh_btn.click(fn=refresh_file_list, outputs=[file_list_status]).then(
+            fn=list_uploaded_files_paginated,
+            inputs=[],
+            outputs=[file_summary, file_details, pagination_info, prev_btn, next_btn]
+        )
+
+        next_btn.click(fn=load_next_page, inputs=[pagination_info], outputs=[file_summary, file_details, pagination_info, prev_btn, next_btn])
+        prev_btn.click(fn=load_prev_page, inputs=[pagination_info], outputs=[file_summary, file_details, pagination_info, prev_btn, next_btn])
+
+    # Launch single app
+    app.launch(server_name="0.0.0.0", server_port=7860, share=False, debug=True, show_error=True)
+
+if __name__ == "__main__":
+    main()