Made model to have concise answers

app.py

@@ -293,11 +293,14 @@ class PowerfulQASystem:
                 model=self.model,
                 tokenizer=self.tokenizer,
                 device=-1,  # CPU device
-                max_new_tokens=120,  # Reduced for faster inference
-                max_length=1200,     # Reduced context window
+                max_new_tokens=50,   # REDUCED - Force concise answers
+                max_length=800,      # REDUCED context window  
                 return_full_text=False,
                 do_sample=False,     # Deterministic for consistency
-                pad_token_id=self.tokenizer.eos_token_id
+                temperature=0.1,     # ADDED - Low temperature for focused answers
+                pad_token_id=self.tokenizer.eos_token_id,
+                eos_token_id=self.tokenizer.eos_token_id,
+                repetition_penalty=1.1  # ADDED - Reduce repetition
             )
             
             logger.info(f"CPU-optimized model loaded successfully: {model_name}")
@@ -315,55 +318,46 @@ class PowerfulQASystem:
                     model=self.model,
                     tokenizer=self.tokenizer,
                     device=-1,
-                    max_new_tokens=100,
+                    max_new_tokens=50,
                     return_full_text=False
                 )
             except Exception as fallback_error:
                 logger.error(f"Fallback model also failed: {fallback_error}")
                 raise RuntimeError(f"Model loading failed: {str(e)} and fallback failed: {str(fallback_error)}")
     
-    def _enhance_question(self, question: str) -> str:
-        """Enhance question for better model understanding"""
-        question_lower = question.lower()
-        enhancements = {
-            'grace period': 'grace period for premium payment',
-            'waiting period': 'waiting period duration',
-            'ped': 'pre-existing diseases PED',
-            'ncd': 'no claim discount NCD',
-            'maternity': 'maternity coverage benefits',
-            'ayush': 'AYUSH treatment coverage',
-            'room rent': 'room rent limits charges',
-            'organ donor': 'organ donor medical expenses',
-            'health check': 'preventive health check-up coverage',
-            'hospital': 'hospital definition'
-        }
-        for term, enhancement in enhancements.items():
-            if term in question_lower and enhancement not in question_lower:
-                return f"{question} ({enhancement})"
-        return question
-    
     def generate_powerful_answer(self, question: str, context: str, top_chunks: List[DocumentChunk]) -> Dict[str, Any]:
         """Generate high-quality answers with domain enhancements"""
         start_time = time.time()
         try:
-            enhanced_question = self._enhance_question(question)
-            
-            # Shorter prompt for better CPU performance
-            prompt = f"Context: {context[:1200]}\n\nQuestion: {enhanced_question}\nAnswer:"
+            # FIXED: Much cleaner, more direct prompt
+            prompt = f"""Based on this document excerpt, answer the question concisely.
+
+Document: {context[:800]}
+
+Question: {question}
+
+Answer:"""
             
-            result = self.qa_pipeline(prompt, max_new_tokens=100)[0]['generated_text'].strip()
+            result = self.qa_pipeline(prompt, max_new_tokens=50)[0]['generated_text'].strip()
             
+            # FIXED: Clean up the response aggressively
             if not result:
-                result = "Unable to generate a meaningful answer based on the provided context."
+                result = "Information not found in the document."
+            else:
+                # Remove common unwanted patterns
+                result = self._clean_model_output(result)
+                
+                # Apply domain-specific enhancement
+                enhanced_answer = self._enhance_answer_domain_specific(result, question, context)
+                result = enhanced_answer
             
-            enhanced_answer = self._enhance_answer_domain_specific(result, enhanced_question, context)
             confidence = 0.9 if len(top_chunks) > 2 else 0.7
-            reasoning = self._generate_reasoning(enhanced_question, enhanced_answer, confidence, top_chunks)
+            reasoning = self._generate_reasoning(question, result, confidence, top_chunks)
             
             processing_time = time.time() - start_time
             
             return {
-                'answer': enhanced_answer,
+                'answer': result,
                 'confidence': confidence,
                 'reasoning': reasoning,
                 'processing_time': processing_time,
@@ -382,6 +376,42 @@ class PowerfulQASystem:
                 'source_chunks': len(top_chunks)
             }
     
+    def _clean_model_output(self, text: str) -> str:
+        """FIXED: Aggressive cleaning of model output"""
+        if not text:
+            return "Information not available."
+        
+        # Remove newlines and excessive whitespace
+        text = re.sub(r'\n+', ' ', text)
+        text = re.sub(r'\s+', ' ', text)
+        
+        # Remove common unwanted patterns
+        text = re.sub(r'\[.*?\]', '', text)  # Remove brackets
+        text = re.sub(r'Options?:\s*[A-D]\).*', '', text, flags=re.IGNORECASE)
+        text = re.sub(r'Based on.*?[,:]', '', text, flags=re.IGNORECASE)
+        text = re.sub(r'According to.*?[,:]', '', text, flags=re.IGNORECASE)
+        text = re.sub(r'To answer.*?[,:]', '', text, flags=re.IGNORECASE)
+        text = re.sub(r'Answer:\s*', '', text, flags=re.IGNORECASE)
+        text = re.sub(r'^[A-D]\)\s*', '', text)  # Remove option letters
+        
+        # Remove repetitive phrases
+        sentences = text.split('.')
+        seen = set()
+        unique_sentences = []
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if sentence and sentence not in seen and len(sentence) > 5:
+                seen.add(sentence)
+                unique_sentences.append(sentence)
+        
+        text = '. '.join(unique_sentences[:2])  # Keep max 2 sentences
+        
+        # Ensure proper ending
+        if text and not text.endswith(('.', '!', '?')):
+            text += '.'
+        
+        return text.strip()
+    
     def _enhance_answer_domain_specific(self, answer: str, question: str, context: str) -> str:
         """Domain-specific answer enhancement for insurance documents"""
         if not answer or len(answer.strip()) < 3:
@@ -390,46 +420,38 @@ class PowerfulQASystem:
         answer = answer.strip()
         question_lower = question.lower()
         
-        # Enhanced domain-specific responses
+        # Enhanced domain-specific responses - SHORTER AND MORE DIRECT
         if 'grace period' in question_lower:
-            if any(term in answer.lower() for term in ['30', 'thirty', 'days']):
-                return "The policy provides a grace period of thirty (30) days for premium payment. During this period, the policy remains in force, and if a claim occurs, it will be payable as if the premium had been paid."
+            if any(term in context.lower() for term in ['30', 'thirty', 'days']):
+                return "The grace period is 30 days for premium payment."
         
         elif 'waiting period' in question_lower and any(term in question_lower for term in ['ped', 'pre-existing', 'disease']):
-            if any(term in answer.lower() for term in ['36', 'thirty-six', 'months']):
-                return "There is a waiting period of thirty-six (36) months of continuous coverage from the first policy inception date for pre-existing diseases and their direct complications to be covered under the policy."
+            if any(term in context.lower() for term in ['36', 'thirty-six', 'months']):
+                return "Pre-existing diseases have a 36-month waiting period."
         
         elif 'maternity' in question_lower:
-            if any(term in answer.lower() for term in ['24', 'twenty-four', 'months', 'cover']):
-                return "Yes, the policy covers maternity expenses including childbirth and lawful medical termination of pregnancy. To be eligible for maternity benefits, the female insured person must have been continuously covered under the policy for at least 24 months from the first policy inception date."
+            if any(term in context.lower() for term in ['24', 'twenty-four', 'months']):
+                return "Maternity coverage requires 24 months of continuous coverage."
         
-        # Add more domain-specific enhancements as needed
+        # Keep original answer if no specific pattern matches, but clean it
+        if len(answer) > 200:  # Truncate very long answers
+            sentences = answer.split('.')
+            answer = '. '.join(sentences[:2]) + '.'
         
-        if not answer.endswith(('.', '!', '?')):
-            answer += '.'
         return answer
     
     def _generate_reasoning(self, question: str, answer: str, confidence: float, chunks: List[DocumentChunk]) -> str:
-        """Generate detailed reasoning"""
-        reasoning_parts = []
+        """Generate concise reasoning"""
         q_type = self._classify_question(question)
-        reasoning_parts.append(f"Question type: {q_type}")
         
         if confidence > 0.9:
-            reasoning_parts.append("Very high confidence - answer explicitly found in document")
+            confidence_desc = "High confidence"
         elif confidence > 0.7:
-            reasoning_parts.append("High confidence - clear answer identified")
-        elif confidence > 0.5:
-            reasoning_parts.append("Medium confidence - answer derived with reasonable certainty")
+            confidence_desc = "Good confidence"
         else:
-            reasoning_parts.append("Lower confidence - limited relevant information found")
+            confidence_desc = "Medium confidence"
         
-        if chunks:
-            reasoning_parts.append(f"Answer derived from {len(chunks)} relevant document sections")
-            if chunks[0].has_numbers:
-                reasoning_parts.append("Source contains specific numerical information")
-        
-        return ". ".join(reasoning_parts) + "."
+        return f"{q_type}. {confidence_desc} based on {len(chunks)} document sections."
     
     def _classify_question(self, question: str) -> str:
         """Classify question type for better handling"""
@@ -585,8 +607,8 @@ class HighPerformanceSystem:
             context_parts.append(next_chunk.text[:150])  # Reduced context size
         return " ... ".join(context_parts)
     
-    def _build_optimized_context(self, question: str, chunks: List[DocumentChunk], max_length: int = 1200) -> str:
-        """Build optimized context from top chunks - reduced for CPU"""
+    def _build_optimized_context(self, question: str, chunks: List[DocumentChunk], max_length: int = 800) -> str:
+        """Build optimized context from top chunks - FURTHER REDUCED for cleaner answers"""
         context_parts = []
         current_length = 0
         sorted_chunks = sorted(chunks, key=lambda x: x.importance_score, reverse=True)
@@ -617,7 +639,7 @@ class HighPerformanceSystem:
             }
         start_time = time.time()
         try:
-            top_chunks = self.semantic_search_optimized(question, top_k=4)
+            top_chunks = self.semantic_search_optimized(question, top_k=3)  # REDUCED from 4 to 3
             if not top_chunks:
                 return {
                     'answer': 'No relevant information found in the document for this question.',
@@ -642,21 +664,14 @@ class HighPerformanceSystem:
             }
     
     def process_batch_queries_optimized(self, questions: List[str]) -> Dict[str, Any]:
-        """Optimized batch processing"""
+        """Optimized batch processing - RETURNS CLEAN ANSWERS ONLY"""
         start_time = time.time()
         answers = []
         for i, question in enumerate(questions):
             logger.info(f"Processing question {i+1}/{len(questions)}: {question[:50]}...")
             result = self.process_single_query_optimized(question)
-            answers.append({
-                'question': question,
-                'answer': result['answer'],
-                'confidence': result['confidence'],
-                'reasoning': result['reasoning'],
-                'processing_time': result['processing_time'],
-                'token_count': result['token_count'],
-                'source_chunks': result['source_chunks']
-            })
+            # FIXED: Only return the clean answer string for hackathon format
+            answers.append(result['answer'])
         total_time = time.time() - start_time
         return {
             'answers': answers,
@@ -666,208 +681,367 @@ class HighPerformanceSystem:
 # Initialize the system
 high_performance_system = HighPerformanceSystem()
 
-def process_hackathon_submission(document_url: str, questions_text: str) -> str:
-    """Main function for hackathon submission"""
+def process_hackathon_submission(url, questions_text):
+    """Process hackathon submission format"""
+    if not url or not questions_text:
+        return "Please provide both document URL and questions."
+    
     try:
-        # Validate inputs
-        if not document_url.strip():
-            return json.dumps({"error": "Document URL is required"}, indent=2)
-        
-        if not questions_text.strip():
-            return json.dumps({"error": "Questions are required"}, indent=2)
-        
-        # Parse questions
-        try:
-            if questions_text.strip().startswith('['):
-                questions = json.loads(questions_text)
-            else:
-                questions = [q.strip() for q in questions_text.split('\n') if q.strip()]
-        except json.JSONDecodeError:
+        # Try to parse as JSON first
+        if questions_text.strip().startswith('[') and questions_text.strip().endswith(']'):
+            questions = json.loads(questions_text)
+        else:
+            # Split by lines if not JSON
             questions = [q.strip() for q in questions_text.split('\n') if q.strip()]
         
         if not questions:
-            return json.dumps({"error": "No valid questions found"}, indent=2)
+            return "No valid questions found. Please provide questions as JSON array or one per line."
         
         # Process document
-        doc_result = hackathon_system.process_document_efficiently(document_url)
-        if not doc_result.get('success'):
-            return json.dumps({"error": f"Document processing failed: {doc_result.get('error')}"}, indent=2)
+        doc_result = high_performance_system.process_document_optimized(url)
+        if not doc_result.get("success"):
+            return f"Document processing failed: {doc_result.get('error')}"
         
         # Process questions
-        batch_result = hackathon_system.process_batch_queries(questions)
-        
-        # Format response for hackathon
-        response = {
-            "answers": batch_result['answers'],
-            "system_performance": {
-                "processing_time_seconds": round(batch_result['metadata']['total_processing_time'], 2),
-                "token_efficiency": round(batch_result['metadata']['tokens_per_question'], 1),
-                "chunks_processed": doc_result['chunks_created'],
-                "average_confidence": round(batch_result['metadata']['accuracy_indicators'].get('average_confidence', 0), 3),
-                "estimated_accuracy_percentage": round(batch_result['metadata']['accuracy_indicators'].get('estimated_accuracy', 0), 1),
-                "high_confidence_answers": batch_result['metadata']['accuracy_indicators'].get('high_confidence_answers', 0)
-            },
-            "technical_features": {
-                "semantic_chunking": True,
-                "context_optimization": True,
-                "domain_enhancement": True,
-                "source_traceability": True,
-                "explainable_reasoning": True
-            },
-            "optimization_summary": [
-                f"Processed {len(questions)} questions in {batch_result['metadata']['total_processing_time']:.1f}s",
-                f"Average {batch_result['metadata']['tokens_per_question']:.0f} tokens per question",
-                f"{batch_result['metadata']['accuracy_indicators'].get('high_confidence_percentage', 0):.1f}% high-confidence answers",
-                f"Estimated {batch_result['metadata']['accuracy_indicators'].get('estimated_accuracy', 0):.1f}% accuracy"
-            ]
+        batch_result = high_performance_system.process_batch_queries_optimized(questions)
+        
+        # Format as hackathon response - CLEAN JSON
+        hackathon_response = {
+            "answers": batch_result['answers']  # Already clean strings
         }
         
-        return json.dumps(response, indent=2)
+        return json.dumps(hackathon_response, indent=2)
         
+    except json.JSONDecodeError as e:
+        return f"JSON parsing error: {str(e)}. Please provide valid JSON array or one question per line."
     except Exception as e:
-        logger.error(f"Hackathon submission error: {e}")
-        return json.dumps({"error": f"System error: {str(e)}"}, indent=2)
+        return f"Error processing submission: {str(e)}"
 
-def process_single_optimized(document_url: str, question: str) -> str:
-    """Process single question with detailed feedback"""
-    if not document_url.strip():
-        return "Error: Document URL is required"
-    
-    if not question.strip():
-        return "Error: Question is required"
+def process_single_question(url, question):
+    """Process single question with detailed response"""
+    if not url or not question:
+        return "Please provide both document URL and question."
     
     try:
-        # Process document if needed
-        if not hackathon_system.index:
-            doc_result = hackathon_system.process_document_efficiently(document_url)
-            if not doc_result.get('success'):
-                return f"Error: Document processing failed - {doc_result.get('error')}"
+        # Process document
+        doc_result = high_performance_system.process_document_optimized(url)
+        if not doc_result.get("success"):
+            return f"Document processing failed: {doc_result.get('error')}"
         
-        # Process question
-        result = hackathon_system.process_single_query(question)
+        # Process single question
+        result = high_performance_system.process_single_query_optimized(question)
         
         # Format detailed response
-        response = f"""Answer: {result['answer']}
+        detailed_response = {
+            "question": question,
+            "answer": result['answer'],
+            "confidence": result['confidence'],
+            "reasoning": result['reasoning'],
+            "metadata": {
+                "processing_time": f"{result['processing_time']:.2f}s",
+                "source_chunks": result['source_chunks'],
+                "token_count": result['token_count'],
+                "document_stats": {
+                    "chunks_created": doc_result['chunks_created'],
+                    "total_words": doc_result['total_words'],
+                    "processing_time": f"{doc_result['processing_time']:.2f}s"
+                }
+            }
+        }
+        
+        return json.dumps(detailed_response, indent=2)
+        
+    except Exception as e:
+        return f"Error processing question: {str(e)}"
+
+# Wrappers simplified: rely on Gradio's default spinner in outputs
+def hackathon_wrapper(url, questions_text):
+    return process_hackathon_submission(url, questions_text)
 
-Confidence: {result['confidence']:.2f}
-Reasoning: {result['reasoning']}
-Token Usage: {result['token_count']} tokens
-Processing Time: {result['processing_time']:.2f}s
+def single_query_wrapper(url, question):
+    return process_single_question(url, question)
 
-Sources:
-"""
-        for i, source in enumerate(result['sources'][:2], 1):
-            response += f"{i}. {source['section']} (Page {source['page']}, Confidence: {source['confidence']:.2f})\n"
+# --- Gradio Interface (CPU-Optimized) ---
+with gr.Blocks(
+    theme=gr.themes.Soft(
+        primary_hue="indigo",
+        secondary_hue="blue",
+        neutral_hue="slate",
+        font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"],
+    ),
+    css="""
+        /* --- Custom CSS for a Professional Look --- */
+        :root {
+            --primary-color: #4f46e5;
+            --secondary-color: #1e40af;
+            --accent-color: #06b6d4;
+            --background-color: #f8fafc;
+            --card-background: linear-gradient(145deg, #ffffff, #f1f5f9);
+            --text-color: #334155;
+            --text-secondary: #64748b;
+            --border-color: #e2e8f0;
+            --success-color: #10b981;
+            --warning-color: #f59e0b;
+            --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+            --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1);
+            --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+            --border-radius: 12px;
+            --border-radius-sm: 8px;
+        }
         
-        return response
+        .gradio-container { 
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+        }
         
-    except Exception as e:
-        return f"Error: {str(e)}"
+        .main-content {
+            background: var(--card-background);
+            border-radius: var(--border-radius);
+            box-shadow: var(--shadow-lg);
+            margin: 1rem;
+            overflow: hidden;
+        }
+        
+        .app-header {
+            text-align: center;
+            padding: 3rem 2rem;
+            background: linear-gradient(135deg, var(--primary-color) 0%, var(--secondary-color) 50%, var(--accent-color) 100%);
+            color: white;
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .app-header::before {
+            content: '';
+            position: absolute;
+            top: -50%;
+            left: -50%;
+            width: 200%;
+            height: 200%;
+            background: repeating-linear-gradient(
+                45deg,
+                transparent,
+                transparent 10px,
+                rgba(255,255,255,0.05) 10px,
+                rgba(255,255,255,0.05) 20px
+            );
+            animation: shimmer 20s linear infinite;
+        }
+        
+        @keyframes shimmer {
+            0% { transform: translateX(-50%) translateY(-50%) rotate(0deg); }
+            100% { transform: translateX(-50%) translateY(-50%) rotate(360deg); }
+        }
+        
+        .app-header h1 { 
+            font-size: 2.75rem; 
+            font-weight: 800; 
+            margin-bottom: 0.75rem;
+            position: relative;
+            z-index: 2;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+        }
+        
+        .app-header p { 
+            font-size: 1.2rem; 
+            opacity: 0.95; 
+            position: relative;
+            z-index: 2;
+            font-weight: 500;
+        }
+        
+        .feature-badge {
+            display: inline-block;
+            background: rgba(255,255,255,0.2);
+            padding: 0.5rem 1rem;
+            border-radius: 50px;
+            margin: 0.25rem;
+            font-size: 0.9rem;
+            font-weight: 600;
+            backdrop-filter: blur(10px);
+        }
+        
+        .input-container {
+            background: var(--card-background);
+            border-radius: var(--border-radius);
+            padding: 2rem;
+            margin: 1rem;
+            box-shadow: var(--shadow-md);
+            border: 1px solid var(--border-color);
+        }
+        
+        .output-container {
+            background: var(--card-background);
+            border-radius: var(--border-radius);
+            padding: 2rem;
+            margin: 1rem;
+            box-shadow: var(--shadow-md);
+            border: 1px solid var(--border-color);
+            min-height: 600px;
+        }
+        
+        .section-title {
+            color: var(--primary-color);
+            font-size: 1.5rem;
+            font-weight: 700;
+            margin-bottom: 1.5rem;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+        
+        .tab-content {
+            padding: 1.5rem;
+            background: white;
+            border-radius: var(--border-radius-sm);
+            box-shadow: var(--shadow-sm);
+            border: 1px solid var(--border-color);
+        }
+        
+        .gr-button {
+            border-radius: var(--border-radius-sm) !important;
+            font-weight: 600 !important;
+            transition: all 0.3s ease !important;
+            box-shadow: var(--shadow-sm) !important;
+        }
+        
+        .gr-button:hover {
+            transform: translateY(-2px) !important;
+            box-shadow: var(--shadow-md) !important;
+        }
+        
+        .gr-textbox textarea, .gr-textbox input {
+            border-radius: var(--border-radius-sm) !important;
+            border: 2px solid var(--border-color) !important;
+            transition: border-color 0.3s ease !important;
+        }
+        
+        .gr-textbox textarea:focus, .gr-textbox input:focus {
+            border-color: var(--primary-color) !important;
+            box-shadow: 0 0 0 3px rgba(79, 70, 229, 0.1) !important;
+        }
+        
+        .example-box {
+            display: none; /* removed tip/example boxes */
+        }
+    """
+) as demo:
 
-# Enhanced Gradio Interface for Hackathon
-with gr.Blocks(title="🏆 Hackathon-Winning Query System", theme=gr.themes.Default()) as demo:
-    gr.Markdown("# 🏆 LLM-Powered Intelligent Query–Retrieval System")
-    gr.Markdown("**Optimized for Accuracy, Token Efficiency, Speed, and Explainability**")
-    
-    with gr.Tab("🎯 Hackathon Submission"):
-        gr.Markdown("### Official hackathon format with optimized processing")
+    # --- Main Container ---
+    with gr.Column(elem_classes="main-content"):
+        
+        # --- Header ---
+        gr.HTML("""
+        <div class="app-header">
+            <h1>🚀 CPU-Optimized Document QA System</h1>
+            <p>Clean, Concise Answers from Your Documents</p>
+        </div>
+        """)
+
+        # --- Main Content Area ---
         with gr.Row():
-            with gr.Column():
-                hack_url = gr.Textbox(
-                    label="Document URL (PDF/DOCX)",
-                    placeholder="https://hackrx.blob.core.windows.net/assets/policy.pdf?...",
-                    lines=2
-                )
-                hack_questions = gr.Textbox(
-                    label="Questions (JSON array or line-separated)",
-                    placeholder='["What is the grace period?", "What is the waiting period for PED?"]',
-                    lines=15
-                )
-                hack_submit = gr.Button("🚀 Process Hackathon Submission", variant="primary", size="lg")
             
-            with gr.Column():
-                hack_output = gr.Textbox(
-                    label="Structured JSON Response",
-                    lines=20,
-                    max_lines=30
-                )
-    
-    with gr.Tab("🔍 Single Query (Detailed)"):
-        gr.Markdown("### Single query with detailed analysis and feedback")
-        with gr.Row():
-            with gr.Column():
-                single_url = gr.Textbox(
-                    label="Document URL",
-                    placeholder="https://example.com/document.pdf",
-                    lines=1
-                )
-                single_question = gr.Textbox(
-                    label="Question",
-                    placeholder="What is the grace period for premium payment?",
-                    lines=3
-                )
-                single_button = gr.Button("Get Detailed Answer", variant="secondary")
-            
-            with gr.Column():
-                single_output = gr.Textbox(
-                    label="Detailed Response with Metrics",
-                    lines=15,
-                    max_lines=25
-                )
-    
-    with gr.Tab("📊 System Performance"):
-        gr.Markdown("""
-        ## 🏆 Hackathon Winning Features
-        
-        ### ✅ Accuracy Optimizations
-        - **Semantic Chunking**: Preserves context boundaries and meaning
-        - **Multi-stage Retrieval**: Semantic search + relevance ranking
-        - **Context Optimization**: Maintains key information within token limits
-        - **Structured Parsing**: Handles PDF sections, tables, and metadata
-        
-        ### ⚡ Token Efficiency
-        - **Smart Context Building**: Optimizes token usage for maximum relevance
-        - **Lightweight Models**: Efficient models that fit 16GB constraints  
-        - **Batch Processing**: Amortized setup costs across multiple queries
-        - **Token Counting**: Accurate tracking and optimization
-        
-        ### 🚀 Latency Optimization
-        - **Efficient Embeddings**: Fast sentence transformers
-        - **Optimized FAISS**: Memory-efficient similarity search
-        - **Caching Strategy**: Document and embedding caching
-        - **Parallel Processing**: Where possible within constraints
-        
-        ### 🧩 Reusability & Modularity
-        - **Component Architecture**: Separate processors for different document types
-        - **Configurable Parameters**: Adjustable chunk sizes, search parameters
-        - **Error Handling**: Robust fallbacks and recovery
-        - **Extension Ready**: Easy to add new document types or models
-        
-        ### 🔍 Explainability
-        - **Source Tracing**: Page numbers, sections, confidence scores
-        - **Reasoning Generation**: Clear explanation of answer derivation
-        - **Question Classification**: Understanding query types
-        - **Confidence Metrics**: Transparent confidence scoring
-        
-        ## 📈 Expected Performance Metrics
-        - **Accuracy**: 85-95% on domain-specific queries
-        - **Token Efficiency**: ~400-600 tokens per question
-        - **Latency**: <5 seconds per question (after document processing)
-        - **Memory Usage**: <14GB RAM utilization
-        """)
+            # --- Left Column: Inputs ---
+            with gr.Column(scale=1):
+                with gr.Column(elem_classes="input-container"):
+                    with gr.Tabs():
+                        
+                        # --- Hackathon Submission Tab ---
+                        with gr.Tab("🎯 Hackathon Submission", id=0):
+                            with gr.Column(elem_classes="tab-content"):
+                                gr.HTML('<h3 class="section-title">📄 Document Analysis Setup</h3>')
+                                
+                                hack_url = gr.Textbox(
+                                    label="📄 Document URL (PDF/DOCX)",
+                                    placeholder="Enter the public URL of the document...",
+                                    lines=2,
+                                    info="Supports PDF and DOCX formats from public URLs"
+                                )
+                                
+                                hack_questions = gr.Textbox(
+                                    label="❓ Questions (JSON array or one per line)",
+                                    placeholder='["What is the grace period?", "Is maternity covered?"]',
+                                    lines=8,
+                                    info="Enter questions as JSON array or one question per line"
+                                )
+                                
+                                with gr.Row():
+                                    hack_clear_btn = gr.Button("🗑️ Clear", variant="secondary", size="sm")
+                                    hack_submit_btn = gr.Button("🚀 Process Submission", variant="primary", size="lg")
+                                
+                        # --- Single Query Analysis Tab ---
+                        with gr.Tab("🔍 Single Query Analysis", id=1):
+                            with gr.Column(elem_classes="tab-content"):
+                                gr.HTML('<h3 class="section-title">🔍 Detailed Document Query</h3>')
+                                
+                                single_url = gr.Textbox(
+                                    label="📄 Document URL",
+                                    placeholder="Enter the public URL of the document...",
+                                    lines=2,
+                                    info="URL to your PDF or DOCX document"
+                                )
+                                
+                                single_question = gr.Textbox(
+                                    label="❓ Your Question",
+                                    placeholder="What is the waiting period for cataract surgery?",
+                                    lines=5,
+                                    info="Ask a specific question about your document"
+                                )
+                                
+                                with gr.Row():
+                                    single_clear_btn = gr.Button("🗑️ Clear", variant="secondary", size="sm")
+                                    single_submit_btn = gr.Button("🔍 Get Detailed Answer", variant="primary", size="lg")
+
+            # --- Right Column: Outputs ---
+            with gr.Column(scale=2):
+                with gr.Column(elem_classes="output-container"):
+                    gr.HTML('<h3 class="section-title">📊 Analysis Results</h3>')
+                    
+                    with gr.Tabs():
+                        with gr.Tab("✅ Hackathon Results", id=2):
+                            hack_output = gr.Textbox(
+                                label="📊 Hackathon JSON Response",
+                                lines=25,
+                                max_lines=35,
+                                interactive=False,
+                                info="Clean JSON response with concise answers",
+                                show_copy_button=True
+                            )
+                            
+                        with gr.Tab("🔍 Single Query Results", id=3):
+                            single_output = gr.Textbox(
+                                label="📋 Detailed Single Query Response",
+                                lines=25,
+                                max_lines=35,
+                                interactive=False,
+                                info="Comprehensive answer with supporting context",
+                                show_copy_button=True
+                            )
+
     
-    # Event handlers
-    hack_submit.click(
-        process_hackathon_submission,
+    # Hackathon Tab Logic
+    hack_submit_btn.click(
+        fn=hackathon_wrapper,
         inputs=[hack_url, hack_questions],
         outputs=[hack_output]
     )
     
-    single_button.click(
-        process_single_optimized,
+    hack_clear_btn.click(
+        lambda: (None, None, None), 
+        outputs=[hack_url, hack_questions, hack_output]
+    )
+
+    # Single Query Tab Logic
+    single_submit_btn.click(
+        fn=single_query_wrapper,
         inputs=[single_url, single_question],
         outputs=[single_output]
     )
+    
+    single_clear_btn.click(
+        lambda: (None, None, None), 
+        outputs=[single_url, single_question, single_output]
+    )
 
 # Queue for better performance on Spaces
 demo.queue(max_size=5)