Model Changes

app.py

@@ -18,6 +18,8 @@ import hashlib
 from fastapi import FastAPI, Request, Header
 from fastapi.responses import JSONResponse
 import warnings
+from urllib.parse import urlparse
+import os
 warnings.filterwarnings('ignore')
 
 # Configure logging
@@ -25,7 +27,7 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # Create FastAPI app for API endpoints
-api_app = FastAPI(title="High-Performance HackRx API", description="Production-grade AI document query system")
+api_app = FastAPI(title="Enhanced Single Document QA API", description="Single document AI query system")
 
 @api_app.post("/hackrx/run")
 async def hackrx_run(
@@ -35,22 +37,28 @@ async def hackrx_run(
 ):
     try:
         data = await request.json()
-        document_url = data.get("documents")
+        documents = data.get("documents")  # Single URL expected
         questions = data.get("questions")
 
-        if not document_url or not questions:
+        if not documents or not questions:
             return JSONResponse(status_code=400, content={"error": "Missing 'documents' or 'questions'"})
 
         if not isinstance(questions, list) or not all(isinstance(q, str) for q in questions):
             return JSONResponse(status_code=400, content={"error": "'questions' must be a list of strings"})
 
+        # Handle single document URL
+        if isinstance(documents, list):
+            document_url = documents[0]  # Take first document only
+        else:
+            document_url = documents
+
         # Process document
-        doc_result = high_performance_system.process_document_optimized(document_url)
+        doc_result = enhanced_system.process_document_optimized(document_url)
         if not doc_result.get("success"):
             return JSONResponse(content={"error": doc_result.get("error")}, status_code=500)
 
         # Answer questions
-        batch_result = high_performance_system.process_batch_queries_optimized(questions)
+        batch_result = enhanced_system.process_batch_queries_optimized(questions)
         answers = batch_result.get("answers", [])
 
         return JSONResponse(content={"answers": answers}, status_code=200)
@@ -60,7 +68,7 @@ async def hackrx_run(
 
 @dataclass
 class DocumentChunk:
-    """Optimized document chunk structure"""
+    """Document chunk structure with source tracking"""
     text: str
     section: str
     page: int
@@ -71,21 +79,21 @@ class DocumentChunk:
     importance_score: float
     context_window: str = ""
 
-class PowerfulDocumentProcessor:
-    """High-performance document processor with advanced text extraction"""
+class EnhancedDocumentProcessor:
+    """Enhanced document processor for single document processing"""
     
     def __init__(self):
         self.cache = {}
-        self.max_cache_size = 10
+        self.max_cache_size = 5
     
     def _get_cache_key(self, content: bytes) -> str:
         return hashlib.md5(content[:1000]).hexdigest()
     
-    def extract_pdf_optimized(self, file_content: bytes) -> Dict[str, Any]:
+    def extract_pdf_optimized(self, file_content: bytes, source_url: str = "") -> Dict[str, Any]:
         """Optimized PDF extraction with better text cleaning"""
         cache_key = self._get_cache_key(file_content)
         if cache_key in self.cache:
-            return self.cache[cache_key]
+            return self.cache[cache_key].copy()
         
         try:
             pdf_reader = PyPDF2.PdfReader(io.BytesIO(file_content))
@@ -96,7 +104,7 @@ class PowerfulDocumentProcessor:
                 try:
                     page_text = page.extract_text()
                     if page_text:
-                        cleaned_text = self._clean_text_aggressive(page_text)
+                        cleaned_text = self._clean_text_comprehensive(page_text)
                         if len(cleaned_text.strip()) > 50:
                             pages_content.append({
                                 'page_num': page_num + 1,
@@ -112,7 +120,8 @@ class PowerfulDocumentProcessor:
                 'pages': pages_content,
                 'full_text': all_text.strip(),
                 'total_pages': len(pages_content),
-                'total_words': len(all_text.split())
+                'total_words': len(all_text.split()),
+                'source_url': source_url
             }
             
             if len(self.cache) >= self.max_cache_size:
@@ -123,9 +132,9 @@ class PowerfulDocumentProcessor:
             
         except Exception as e:
             logger.error(f"PDF extraction error: {e}")
-            return {'pages': [], 'full_text': '', 'total_pages': 0, 'total_words': 0}
+            return {'pages': [], 'full_text': '', 'total_pages': 0, 'total_words': 0, 'source_url': source_url}
     
-    def extract_docx_optimized(self, file_content: bytes) -> Dict[str, Any]:
+    def extract_docx_optimized(self, file_content: bytes, source_url: str = "") -> Dict[str, Any]:
         """Optimized DOCX extraction"""
         try:
             doc = docx.Document(io.BytesIO(file_content))
@@ -134,7 +143,7 @@ class PowerfulDocumentProcessor:
             
             for para in doc.paragraphs:
                 if para.text.strip():
-                    cleaned_text = self._clean_text_aggressive(para.text)
+                    cleaned_text = self._clean_text_comprehensive(para.text)
                     if len(cleaned_text.strip()) > 20:
                         paragraphs.append(cleaned_text)
                         full_text += " " + cleaned_text
@@ -144,52 +153,157 @@ class PowerfulDocumentProcessor:
                 'full_text': full_text.strip(),
                 'total_pages': 1,
                 'total_words': len(full_text.split()),
-                'paragraphs': paragraphs
+                'paragraphs': paragraphs,
+                'source_url': source_url
             }
             
         except Exception as e:
             logger.error(f"DOCX extraction error: {e}")
-            return {'pages': [], 'full_text': '', 'total_pages': 0, 'total_words': 0}
+            return {'pages': [], 'full_text': '', 'total_pages': 0, 'total_words': 0, 'source_url': source_url}
     
-    def _clean_text_aggressive(self, text: str) -> str:
-        """Aggressive text cleaning for better processing"""
+    def _clean_text_comprehensive(self, text: str) -> str:
+        """Comprehensive text cleaning for better processing"""
         if not text:
             return ""
         
+        # Basic cleaning
         text = re.sub(r'\s+', ' ', text.strip())
-        text = re.sub(r'([a-z])([A-Z])', r'\1 \2', text)
+        
+        # Fix spacing around punctuation
+        text = re.sub(r'\s+([.,:;!?])', r'\1', text)
+        text = re.sub(r'([.!?])\s*([A-Z])', r'\1 \2', text)
+        
+        # Fix spacing around numbers
         text = re.sub(r'(\d+)([A-Za-z])', r'\1 \2', text)
         text = re.sub(r'([A-Za-z])(\d+)', r'\1 \2', text)
+        
+        # Normalize common insurance terms
         text = re.sub(r'(\d+)\s*months?', r'\1 months', text, flags=re.IGNORECASE)
         text = re.sub(r'(\d+)\s*days?', r'\1 days', text, flags=re.IGNORECASE)
         text = re.sub(r'(\d+)\s*years?', r'\1 years', text, flags=re.IGNORECASE)
         text = re.sub(r'Rs\.?\s*(\d+)', r'Rs. \1', text, flags=re.IGNORECASE)
+        
+        # Remove page numbers and headers/footers
         text = re.sub(r'Page\s+\d+\s+of\s+\d+', '', text, flags=re.IGNORECASE)
         text = re.sub(r'^\d+\s*$', '', text, flags=re.MULTILINE)
         text = re.sub(r'^[-\s]*$', '', text, flags=re.MULTILINE)
-        text = re.sub(r'\s+([.,:;!?])', r'\1', text)
-        text = re.sub(r'([.!?])\s*([A-Z])', r'\1 \2', text)
+        
+        # Fix camelCase words
+        text = re.sub(r'([a-z])([A-Z])', r'\1 \2', text)
         
         return text.strip()
 
-class OptimizedChunker:
-    """Optimized chunking for better CPU performance"""
+class EnhancedChunker:
+    """Enhanced chunking with better context preservation"""
     
-    def __init__(self, chunk_size: int = 384, overlap: int = 80, min_chunk_size: int = 100):
+    def __init__(self, chunk_size: int = 400, overlap: int = 100, min_chunk_size: int = 120):
         self.chunk_size = chunk_size
         self.overlap = overlap
         self.min_chunk_size = min_chunk_size
     
     def create_smart_chunks(self, structured_content: Dict[str, Any]) -> List[DocumentChunk]:
-        """Create optimized chunks with overlap and context"""
+        """Create optimized chunks with better context preservation"""
         chunks = []
         chunk_id = 0
         
         full_text = structured_content.get('full_text', '')
+        
         if not full_text:
             return chunks
         
-        paragraphs = re.split(r'\n\s*\n|\. {2,}', full_text)
+        # First, try to split by logical sections (headings, numbered items, etc.)
+        sections = self._identify_sections(full_text)
+        
+        for section_text in sections:
+            section_chunks = self._chunk_section(section_text, chunk_id)
+            chunks.extend(section_chunks)
+            chunk_id += len(section_chunks)
+        
+        # If no sections found, fall back to paragraph-based chunking
+        if not chunks:
+            chunks = self._chunk_by_paragraphs(full_text, chunk_id)
+        
+        logger.info(f"Created {len(chunks)} chunks from document")
+        return chunks
+    
+    def _identify_sections(self, text: str) -> List[str]:
+        """Identify logical sections in the text"""
+        # Look for common insurance document patterns
+        section_patterns = [
+            r'\n\s*(?:SECTION|Section|ARTICLE|Article|CLAUSE|Clause)\s+[\dIVXLC]+[.\s]+[^\n]+',
+            r'\n\s*\d+\.\s*[A-Z][^\n]+',  # Numbered headings
+            r'\n\s*[A-Z][A-Z\s]{10,}:',   # All caps headings
+            r'\n\s*(?:Benefits|Coverage|Exclusions|Conditions|Definitions)[^\n]*:',
+        ]
+        
+        # Try to split by sections
+        for pattern in section_patterns:
+            matches = list(re.finditer(pattern, text, re.IGNORECASE))
+            if len(matches) >= 2:  # At least 2 sections
+                sections = []
+                for i, match in enumerate(matches):
+                    start = match.start()
+                    end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+                    section_text = text[start:end].strip()
+                    if len(section_text) > 100:  # Meaningful section size
+                        sections.append(section_text)
+                
+                if sections:
+                    return sections
+        
+        return []  # No clear sections found
+    
+    def _chunk_section(self, section_text: str, start_chunk_id: int) -> List[DocumentChunk]:
+        """Chunk a single section"""
+        chunks = []
+        chunk_id = start_chunk_id
+        
+        # Split section into sentences
+        sentences = re.split(r'[.!?]+\s+', section_text)
+        sentences = [s.strip() + '.' for s in sentences if s.strip()]
+        
+        current_chunk = ""
+        current_words = 0
+        
+        for sentence in sentences:
+            sentence_words = len(sentence.split())
+            
+            if current_words + sentence_words > self.chunk_size and current_chunk:
+                if current_words >= self.min_chunk_size:
+                    chunk = self._create_chunk(current_chunk.strip(), chunk_id, 1, "Section")
+                    chunks.append(chunk)
+                    chunk_id += 1
+                
+                # Start new chunk with overlap
+                if chunks:
+                    # Take last 2 sentences as overlap
+                    last_sentences = current_chunk.split('.')[-3:-1]
+                    overlap_text = '. '.join(s.strip() for s in last_sentences if s.strip()) + '. '
+                    current_chunk = overlap_text + sentence
+                    current_words = len(current_chunk.split())
+                else:
+                    current_chunk = sentence
+                    current_words = sentence_words
+            else:
+                if current_chunk:
+                    current_chunk += " " + sentence
+                else:
+                    current_chunk = sentence
+                current_words += sentence_words
+        
+        # Add final chunk
+        if current_chunk.strip() and current_words >= self.min_chunk_size:
+            chunk = self._create_chunk(current_chunk.strip(), chunk_id, 1, "Section")
+            chunks.append(chunk)
+        
+        return chunks
+    
+    def _chunk_by_paragraphs(self, text: str, start_chunk_id: int) -> List[DocumentChunk]:
+        """Fallback chunking by paragraphs"""
+        chunks = []
+        chunk_id = start_chunk_id
+        
+        paragraphs = re.split(r'\n\s*\n|\. {2,}', text)
         paragraphs = [p.strip() for p in paragraphs if len(p.strip()) > 30]
         
         current_chunk = ""
@@ -200,11 +314,11 @@ class OptimizedChunker:
             
             if current_words + para_words > self.chunk_size and current_chunk:
                 if current_words >= self.min_chunk_size:
-                    chunks.append(self._create_chunk(
-                        current_chunk.strip(), chunk_id, 1, "Document"
-                    ))
+                    chunk = self._create_chunk(current_chunk.strip(), chunk_id, 1, "Document")
+                    chunks.append(chunk)
                     chunk_id += 1
                 
+                # Add overlap
                 if chunks:
                     sentences = re.split(r'[.!?]+\s+', current_chunk)
                     overlap_sentences = sentences[-2:] if len(sentences) >= 2 else sentences
@@ -218,19 +332,20 @@ class OptimizedChunker:
                 current_chunk += " " + para if current_chunk else para
                 current_words += para_words
         
+        # Add final chunk
         if current_chunk.strip() and current_words >= self.min_chunk_size:
-            chunks.append(self._create_chunk(
-                current_chunk.strip(), chunk_id, 1, "Document"
-            ))
+            chunk = self._create_chunk(current_chunk.strip(), chunk_id, 1, "Document")
+            chunks.append(chunk)
         
-        if not chunks and full_text:
-            chunks.append(self._create_chunk(full_text, 0, 1, "Document"))
+        # Ensure we have at least one chunk
+        if not chunks and text.strip():
+            chunk = self._create_chunk(text.strip(), 0, 1, "Document")
+            chunks.append(chunk)
         
-        logger.info(f"Created {len(chunks)} optimized chunks")
         return chunks
     
     def _create_chunk(self, text: str, chunk_id: int, page_num: int, section: str) -> DocumentChunk:
-        """Create a document chunk with metadata"""
+        """Create a document chunk with enhanced metadata"""
         return DocumentChunk(
             text=text,
             section=section,
@@ -247,44 +362,67 @@ class OptimizedChunker:
         score = 1.0
         text_lower = text.lower()
         
+        # Generic insurance terms (not hardcoded to specific company)
         insurance_terms = [
             'premium', 'deductible', 'coverage', 'claim', 'policy', 'waiting period',
-            'grace period', 'maternity', 'pre-existing', 'ncd', 'sum insured', 'ayush',
-            'organ donor', 'health check', 'hospital', 'room rent'
+            'grace period', 'maternity', 'pre-existing', 'sum insured', 'benefit',
+            'exclusion', 'inclusion', 'hospital', 'treatment', 'medical', 'health',
+            'co-payment', 'copayment', 'cashless', 'reimbursement', 'network'
         ]
         
-        term_count = sum(1 for term in insurance_terms if term in text_lower)
-        score += term_count * 0.2
+        # Financial/numerical terms
+        financial_terms = [
+            'amount', 'cost', 'fee', 'charge', 'limit', 'maximum', 'minimum',
+            'percentage', 'rate', 'liability', 'compensation', 'rupees', 'rs'
+        ]
         
+        # Time-related terms
+        time_terms = ['days', 'months', 'years', 'duration', 'period', 'term', 'validity']
+        
+        # Action/requirement terms
+        action_terms = ['shall', 'will', 'must', 'required', 'mandatory', 'provided', 'covered']
+        
+        # Calculate scores
+        insurance_count = sum(1 for term in insurance_terms if term in text_lower)
+        financial_count = sum(1 for term in financial_terms if term in text_lower)
+        time_count = sum(1 for term in time_terms if term in text_lower)
+        action_count = sum(1 for term in action_terms if term in text_lower)
+        
+        score += insurance_count * 0.3
+        score += financial_count * 0.2
+        score += time_count * 0.2
+        score += action_count * 0.15
+        
+        # Boost for numerical information
         if re.search(r'\d+\s*(days?|months?|years?)', text_lower):
-            score += 0.3
+            score += 0.4
         if re.search(r'rs\.?\s*\d+|\d+%', text_lower):
+            score += 0.4
+        if re.search(r'\d+\s*(lakh|crore)', text_lower):
             score += 0.3
         
-        return min(score, 3.0)
+        return min(score, 5.0)
 
-class PowerfulQASystem:
-    """CPU-optimized QA system using smaller models"""
+class EnhancedQASystem:
+    """Enhanced QA system with better answer generation"""
     
     def __init__(self):
         self.qa_pipeline = None
         self.tokenizer = None
         self.model = None
-        self.initialize_powerful_models()
-    
-    def initialize_powerful_models(self):
-        """Initialize CPU-friendly model without quantization"""
-        # Using smaller model for better CPU performance
+        self.initialize_models()
+
+    def initialize_models(self):
+        """Initialize CPU-friendly model"""
         model_name = "Qwen/Qwen2.5-1.5B-Instruct"
-        logger.info(f"Loading CPU-optimized model: {model_name}")
+        logger.info(f"Loading model: {model_name}")
         try:
             self.tokenizer = AutoTokenizer.from_pretrained(model_name)
             
-            # CPU-only configuration - no quantization
             self.model = AutoModelForCausalLM.from_pretrained(
                 model_name,
-                torch_dtype=torch.float32,  # Use float32 for CPU
-                device_map=None,  # Let it use CPU
+                torch_dtype=torch.float32,
+                device_map=None,
                 low_cpu_mem_usage=True
             )
             
@@ -292,269 +430,377 @@ class PowerfulQASystem:
                 "text-generation",
                 model=self.model,
                 tokenizer=self.tokenizer,
-                device=-1,  # CPU device
-                max_new_tokens=50,   # REDUCED - Force concise answers
-                max_length=800,      # REDUCED context window  
+                device=-1,
+                max_new_tokens=50,
+                max_length=1200,
                 return_full_text=False,
-                do_sample=False,     # Deterministic for consistency
-                temperature=0.1,     # ADDED - Low temperature for focused answers
+                do_sample=False,
+                temperature=0.1,
                 pad_token_id=self.tokenizer.eos_token_id,
                 eos_token_id=self.tokenizer.eos_token_id,
-                repetition_penalty=1.1  # ADDED - Reduce repetition
+                repetition_penalty=1.2
             )
             
-            logger.info(f"CPU-optimized model loaded successfully: {model_name}")
+            logger.info(f"Model loaded successfully: {model_name}")
             
         except Exception as e:
             logger.error(f"Failed to load model: {e}")
-            # Fallback to even smaller model if needed
-            try:
-                model_name = "microsoft/DialoGPT-small"
-                logger.info(f"Falling back to: {model_name}")
-                self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-                self.model = AutoModelForCausalLM.from_pretrained(model_name)
-                self.qa_pipeline = pipeline(
-                    "text-generation",
-                    model=self.model,
-                    tokenizer=self.tokenizer,
-                    device=-1,
-                    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)}")
+            raise RuntimeError(f"Model loading failed: {str(e)}")
     
-    def generate_powerful_answer(self, question: str, context: str, top_chunks: List[DocumentChunk]) -> Dict[str, Any]:
-        """Generate high-quality answers with domain enhancements"""
+    def generate_answer(self, question: str, context: str, top_chunks: List[DocumentChunk]) -> Dict[str, Any]:
+        """Generate answer with comprehensive context analysis"""
         start_time = time.time()
         try:
-            # FIXED: Much cleaner, more direct prompt
-            prompt = f"""Based on this document excerpt, answer the question concisely.
+            # First try pattern-based extraction
+            direct_answer = self._extract_comprehensive_answer(question, context)
+            if direct_answer:
+                return {
+                    'answer': direct_answer,
+                    'confidence': 0.95,
+                    'reasoning': "Direct extraction from document content",
+                    'processing_time': time.time() - start_time,
+                    'source_chunks': len(top_chunks)
+                }
+            
+            # Enhanced prompt for better context understanding
+            prompt = f"""You are an insurance document analyzer. Based on the given context, provide a precise, direct answer to the question. Focus on extracting exact information from the context.
 
-Document: {context[:800]}
+Context from insurance document:
+{context[:900]}
 
 Question: {question}
 
+Provide a clear, specific answer based only on the information in the context. If the information is not available, say so.
+
 Answer:"""
             
-            result = self.qa_pipeline(prompt, max_new_tokens=50)[0]['generated_text'].strip()
+            result = self.qa_pipeline(
+                prompt, 
+                max_new_tokens=40,
+                do_sample=False,
+                temperature=0.1
+            )[0]['generated_text'].strip()
             
-            # FIXED: Clean up the response aggressively
             if not result:
-                result = "Information not found in the document."
+                result = "Information not available 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
+                result = self._clean_and_validate_answer(result, context)
             
-            confidence = 0.9 if len(top_chunks) > 2 else 0.7
-            reasoning = self._generate_reasoning(question, result, confidence, top_chunks)
-            
-            processing_time = time.time() - start_time
+            confidence = 0.8 if "not available" not in result.lower() else 0.3
             
             return {
                 'answer': result,
                 'confidence': confidence,
-                'reasoning': reasoning,
-                'processing_time': processing_time,
-                'token_count': len(self.tokenizer.encode(prompt)),
+                'reasoning': "Generated from document analysis",
+                'processing_time': time.time() - start_time,
                 'source_chunks': len(top_chunks)
             }
             
         except Exception as e:
             logger.error(f"Answer generation error: {e}")
             return {
-                'answer': f"Error generating answer: {str(e)}",
+                'answer': f"Error processing question: {str(e)}",
                 'confidence': 0.0,
                 'reasoning': f"Generation failed: {str(e)}",
                 'processing_time': time.time() - start_time,
-                'token_count': 0,
                 'source_chunks': len(top_chunks)
             }
     
-    def _clean_model_output(self, text: str) -> str:
-        """FIXED: Aggressive cleaning of model output"""
+    def _extract_comprehensive_answer(self, question: str, context: str) -> Optional[str]:
+        """Comprehensive pattern-based answer extraction"""
+        question_lower = question.lower()
+        context_lower = context.lower()
+        
+        # Grace period patterns
+        if 'grace period' in question_lower:
+            patterns = [
+                r'grace period[^.]*?(\d+)\s*days?',
+                r'(\d+)\s*days?[^.]*?grace period',
+                r'premium.*?(\d+)\s*days?.*?grace',
+                r'thirty\s*days?[^.]*?grace',
+                r'grace[^.]*?thirty\s*days?',
+                r'(\d+)\s*days?.*?grace.*?period'
+            ]
+            
+            # Check for "thirty" spelled out
+            if any(word in context_lower for word in ['thirty', '30']) and 'days' in context_lower and 'grace' in context_lower:
+                return "The grace period is 30 days for premium payment."
+            
+            for pattern in patterns:
+                match = re.search(pattern, context_lower)
+                if match and match.groups():
+                    days = match.group(1)
+                    return f"The grace period is {days} days for premium payment."
+        
+        # Waiting period patterns
+        if 'waiting period' in question_lower:
+            # Pre-existing disease waiting period
+            if any(term in question_lower for term in ['ped', 'pre-existing', 'disease']):
+                patterns = [
+                    r'pre.?existing[^.]*?(\d+)\s*months?[^.]*?waiting',
+                    r'waiting[^.]*?(\d+)\s*months?[^.]*?pre.?existing',
+                    r'(\d+)\s*months?[^.]*?pre.?existing[^.]*?disease'
+                ]
+                for pattern in patterns:
+                    match = re.search(pattern, context_lower)
+                    if match:
+                        months = match.group(1)
+                        return f"Pre-existing diseases have a {months}-month waiting period."
+            
+            # General waiting period
+            patterns = [
+                r'waiting period[^.]*?(\d+)\s*(days?|months?)',
+                r'(\d+)\s*(days?|months?)[^.]*?waiting period',
+                r'wait.*?(\d+)\s*(days?|months?)',
+                r'(\d+)\s*(months?|days?)[^.]*?wait'
+            ]
+            for pattern in patterns:
+                match = re.search(pattern, context_lower)
+                if match:
+                    number, unit = match.groups()
+                    return f"The waiting period is {number} {unit}."
+        
+        # Maternity coverage
+        if 'maternity' in question_lower:
+            if any(num in context_lower for num in ['24', 'twenty-four', 'twenty four']):
+                if 'months' in context_lower:
+                    return "Maternity coverage requires 24 months of continuous coverage."
+            if re.search(r'maternity[^.]*?covered', context_lower):
+                return "Yes, maternity is covered under the policy."
+            if re.search(r'maternity[^.]*?(not covered|excluded)', context_lower):
+                return "No, maternity is not covered under the policy."
+        
+        # Room rent limits
+        if 'room rent' in question_lower or 'room charges' in question_lower:
+            patterns = [
+                r'room rent[^.]*?(\d+)%',
+                r'(\d+)%[^.]*?room rent',
+                r'room charges[^.]*?(\d+)%',
+                r'accommodation[^.]*?(\d+)%',
+                r'(\d+)%[^.]*?sum insured[^.]*?room'
+            ]
+            for pattern in patterns:
+                match = re.search(pattern, context_lower)
+                if match:
+                    percentage = match.group(1)
+                    return f"Room rent is limited to {percentage}% of sum insured."
+        
+        # Co-payment
+        if 'co-payment' in question_lower or 'copayment' in question_lower:
+            patterns = [
+                r'co.?payment[^.]*?(\d+)%',
+                r'(\d+)%[^.]*?co.?payment',
+                r'patient[^.]*?bear[^.]*?(\d+)%',
+                r'insured[^.]*?pay[^.]*?(\d+)%'
+            ]
+            for pattern in patterns:
+                match = re.search(pattern, context_lower)
+                if match:
+                    percentage = match.group(1)
+                    return f"Co-payment is {percentage}% of the claim amount."
+        
+        # Sum insured/Coverage amount
+        if any(term in question_lower for term in ['sum insured', 'coverage amount', 'maximum coverage', 'policy amount']):
+            patterns = [
+                r'sum insured[^.]*?rs\.?\s*(\d+(?:,\d+)*(?:\s*lakh)?)',
+                r'rs\.?\s*(\d+(?:,\d+)*(?:\s*lakh)?)[^.]*?sum insured',
+                r'coverage[^.]*?rs\.?\s*(\d+(?:,\d+)*(?:\s*lakh)?)',
+                r'maximum.*?benefit.*?rs\.?\s*(\d+(?:,\d+)*(?:\s*lakh)?)',
+                r'policy.*?amount.*?rs\.?\s*(\d+(?:,\d+)*(?:\s*lakh)?)'
+            ]
+            for pattern in patterns:
+                match = re.search(pattern, context_lower)
+                if match:
+                    amount = match.group(1)
+                    return f"The sum insured/coverage amount is Rs. {amount}."
+        
+        # Age limits
+        if 'age' in question_lower and any(term in question_lower for term in ['limit', 'maximum', 'minimum', 'entry']):
+            patterns = [
+                r'age[^.]*?(\d+)\s*years?[^.]*?(maximum|minimum|limit)',
+                r'(maximum|minimum)[^.]*?age[^.]*?(\d+)\s*years?',
+                r'entry[^.]*?age[^.]*?(\d+)\s*years?'
+            ]
+            for pattern in patterns:
+                match = re.search(pattern, context_lower)
+                if match:
+                    groups = match.groups()
+                    if len(groups) >= 2:
+                        age = groups[0] if groups[0].isdigit() else groups[1]
+                        limit_type = groups[1] if groups[0].isdigit() else groups[0]
+                        return f"The {limit_type} age limit is {age} years."
+        
+        return None
+    
+    def _clean_and_validate_answer(self, text: str, context: str) -> str:
+        """Clean and validate model output"""
         if not text:
-            return "Information not available."
+            return "Information not available in the document."
         
-        # Remove newlines and excessive whitespace
+        # Remove unwanted patterns
         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'\[.*?\]', '', text)
         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
+        # Remove repetitive content
         sentences = text.split('.')
-        seen = set()
         unique_sentences = []
+        seen = set()
+        
         for sentence in sentences:
             sentence = sentence.strip()
-            if sentence and sentence not in seen and len(sentence) > 5:
+            if sentence and sentence not in seen and len(sentence) > 10:
                 seen.add(sentence)
                 unique_sentences.append(sentence)
         
-        text = '. '.join(unique_sentences[:2])  # Keep max 2 sentences
+        # Take first 2 sentences max
+        text = '. '.join(unique_sentences[:2])
         
         # Ensure proper ending
         if text and not text.endswith(('.', '!', '?')):
             text += '.'
         
+        # Validate against context
+        if not self._validate_answer_against_context(text, context):
+            return "Information not available in the document."
+        
         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:
-            return "The requested information is not clearly specified in the document."
+    def _validate_answer_against_context(self, answer: str, context: str) -> bool:
+        """Validate that the answer is grounded in the context"""
+        if not answer or "not available" in answer.lower():
+            return True
         
-        answer = answer.strip()
-        question_lower = question.lower()
+        answer_lower = answer.lower()
+        context_lower = context.lower()
         
-        # Enhanced domain-specific responses - SHORTER AND MORE DIRECT
-        if 'grace period' in question_lower:
-            if any(term in context.lower() for term in ['30', 'thirty', 'days']):
-                return "The grace period is 30 days for premium payment."
+        # Extract key numbers from answer
+        answer_numbers = re.findall(r'\d+', answer_lower)
         
-        elif 'waiting period' in question_lower and any(term in question_lower for term in ['ped', 'pre-existing', 'disease']):
-            if any(term in context.lower() for term in ['36', 'thirty-six', 'months']):
-                return "Pre-existing diseases have a 36-month waiting period."
+        # Check if key numbers exist in context
+        for number in answer_numbers:
+            if number not in context_lower:
+                return False
         
-        elif 'maternity' in question_lower:
-            if any(term in context.lower() for term in ['24', 'twenty-four', 'months']):
-                return "Maternity coverage requires 24 months of continuous coverage."
+        # Check key terms overlap
+        answer_words = set(re.findall(r'\b\w+\b', answer_lower))
+        context_words = set(re.findall(r'\b\w+\b', context_lower))
         
-        # 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]) + '.'
+        # Remove common words
+        common_words = {'the', 'is', 'are', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+                       'of', 'with', 'by', 'from', 'as', 'be', 'have', 'has', 'will', 'this', 'that'}
         
-        return answer
-    
-    def _generate_reasoning(self, question: str, answer: str, confidence: float, chunks: List[DocumentChunk]) -> str:
-        """Generate concise reasoning"""
-        q_type = self._classify_question(question)
-        
-        if confidence > 0.9:
-            confidence_desc = "High confidence"
-        elif confidence > 0.7:
-            confidence_desc = "Good confidence"
-        else:
-            confidence_desc = "Medium confidence"
+        meaningful_answer_words = answer_words - common_words
+        meaningful_context_words = context_words - common_words
         
-        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"""
-        question_lower = question.lower()
-        if 'grace period' in question_lower:
-            return "Grace Period Query"
-        elif 'waiting period' in question_lower:
-            return "Waiting Period Query"
-        elif 'maternity' in question_lower:
-            return "Maternity Coverage Query"
-        elif 'ncd' in question_lower or 'no claim discount' in question_lower:
-            return "No Claim Discount Query"
-        elif 'organ donor' in question_lower:
-            return "Organ Donor Coverage Query"
-        elif 'ayush' in question_lower:
-            return "AYUSH Treatment Query"
-        elif 'hospital' in question_lower and 'define' in question_lower:
-            return "Hospital Definition Query"
-        elif 'room rent' in question_lower:
-            return "Room Rent Limits Query"
-        elif 'health check' in question_lower:
-            return "Health Checkup Query"
-        elif 'cataract' in question_lower:
-            return "Cataract Surgery Query"
-        else:
-            return "General Policy Query"
+        if not meaningful_answer_words:
+            return True
+        
+        # Check overlap ratio
+        overlap = meaningful_answer_words.intersection(meaningful_context_words)
+        overlap_ratio = len(overlap) / len(meaningful_answer_words)
+        
+        return overlap_ratio >= 0.6  # At least 60% of meaningful words should be in context
 
-class HighPerformanceSystem:
-    """Main system orchestrating all components"""
+class EnhancedSingleDocumentSystem:
+    """Enhanced system optimized for single document processing"""
     
     def __init__(self):
-        self.doc_processor = PowerfulDocumentProcessor()
-        self.chunker = OptimizedChunker()
-        self.qa_system = PowerfulQASystem()
+        self.doc_processor = EnhancedDocumentProcessor()
+        self.chunker = EnhancedChunker()
+        self.qa_system = EnhancedQASystem()
         self.embedding_model = None
         self.index = None
         self.document_chunks = []
         self.chunk_embeddings = None
+        self.document_processed = False
         self.initialize_embeddings()
     
     def initialize_embeddings(self):
-        """Initialize CPU-friendly embedding model"""
+        """Initialize embedding model"""
         try:
-            # Using smaller, faster embedding model for CPU
             self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
             self.embedding_model.max_seq_length = 384
-            logger.info("CPU-optimized embedding model loaded: all-MiniLM-L6-v2")
+            logger.info("Embedding model loaded: all-MiniLM-L6-v2")
         except Exception as e:
             logger.error(f"Embedding model error: {e}")
             raise RuntimeError(f"Embedding model failed to load: {str(e)}")
     
     def process_document_optimized(self, url: str) -> Dict[str, Any]:
-        """Optimized document processing pipeline"""
+        """Process single document with comprehensive analysis"""
         start_time = time.time()
+        
         try:
             logger.info(f"Processing document: {url}")
+            
+            # Download document
             response = self._download_with_retry(url)
             if not response:
-                return {'success': False, 'error': 'Failed to download document'}
+                return {'success': False, 'error': f'Failed to download document from {url}'}
             
+            # Determine document type and extract
             content_type = response.headers.get('content-type', '').lower()
             if 'pdf' in content_type or url.lower().endswith('.pdf'):
-                structured_content = self.doc_processor.extract_pdf_optimized(response.content)
+                structured_content = self.doc_processor.extract_pdf_optimized(response.content, url)
             elif 'docx' in content_type or url.lower().endswith('.docx'):
-                structured_content = self.doc_processor.extract_docx_optimized(response.content)
+                structured_content = self.doc_processor.extract_docx_optimized(response.content, url)
             else:
-                text_content = response.content.decode('utf-8', errors='ignore')
-                structured_content = {
-                    'pages': [{'page_num': 1, 'text': text_content, 'word_count': len(text_content.split())}],
-                    'full_text': text_content,
-                    'total_pages': 1,
-                    'total_words': len(text_content.split())
-                }
+                # Try to handle as text
+                try:
+                    text_content = response.content.decode('utf-8', errors='ignore')
+                    structured_content = {
+                        'pages': [{'page_num': 1, 'text': text_content, 'word_count': len(text_content.split())}],
+                        'full_text': text_content,
+                        'total_pages': 1,
+                        'total_words': len(text_content.split()),
+                        'source_url': url
+                    }
+                except Exception as e:
+                    return {'success': False, 'error': f'Unsupported document type or encoding error: {str(e)}'}
             
             if not structured_content.get('full_text'):
-                return {'success': False, 'error': 'No text content extracted from document'}
+                return {'success': False, 'error': 'No text content could be extracted from the document'}
             
+            # Create optimized chunks
             self.document_chunks = self.chunker.create_smart_chunks(structured_content)
+            
             if not self.document_chunks:
-                return {'success': False, 'error': 'No meaningful chunks created from document'}
+                return {'success': False, 'error': 'No meaningful content chunks could be created from the document'}
             
+            # Create embeddings for chunks
             chunk_texts = [chunk.text for chunk in self.document_chunks]
-            self.chunk_embeddings = self.embedding_model.encode(
-                chunk_texts,
-                batch_size=4,  # Smaller batch size for CPU
-                show_progress_bar=False,
-                convert_to_numpy=True,
-                normalize_embeddings=True
-            )
             
-            # Using faiss-cpu
-            dimension = self.chunk_embeddings.shape[1]
-            self.index = faiss.IndexFlatIP(dimension)
-            self.index.add(self.chunk_embeddings.astype('float32'))
+            try:
+                self.chunk_embeddings = self.embedding_model.encode(
+                    chunk_texts,
+                    batch_size=8,
+                    show_progress_bar=False,
+                    convert_to_numpy=True,
+                    normalize_embeddings=True
+                )
+                
+                # Create FAISS index
+                dimension = self.chunk_embeddings.shape[1]
+                self.index = faiss.IndexFlatIP(dimension)
+                self.index.add(self.chunk_embeddings.astype('float32'))
+                
+            except Exception as e:
+                return {'success': False, 'error': f'Embedding creation failed: {str(e)}'}
             
+            self.document_processed = True
             processing_time = time.time() - start_time
+            
             logger.info(f"Document processed successfully: {len(self.document_chunks)} chunks in {processing_time:.2f}s")
             
             return {
                 'success': True,
-                'chunks_created': len(self.document_chunks),
-                'processing_time': processing_time,
-                'total_words': structured_content.get('total_words', 0)
+                'total_chunks': len(self.document_chunks),
+                'total_words': structured_content.get('total_words', 0),
+                'total_pages': structured_content.get('total_pages', 0),
+                'processing_time': processing_time
             }
             
         except Exception as e:
@@ -562,96 +808,193 @@ class HighPerformanceSystem:
             return {'success': False, 'error': str(e)}
     
     def _download_with_retry(self, url: str, max_retries: int = 3) -> Optional[requests.Response]:
-        """Download with retry logic"""
+        """Download document with retry logic"""
         headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
         }
+        
         for attempt in range(max_retries):
             try:
                 response = requests.get(url, headers=headers, timeout=30, stream=True)
                 response.raise_for_status()
                 return response
             except Exception as e:
-                logger.warning(f"Download attempt {attempt + 1} failed: {e}")
+                logger.warning(f"Download attempt {attempt + 1} failed for {url}: {e}")
                 if attempt < max_retries - 1:
-                    time.sleep(2 ** attempt)
+                    time.sleep(2 ** attempt)  # Exponential backoff
+        
         return None
     
-    def semantic_search_optimized(self, query: str, top_k: int = 4) -> List[DocumentChunk]:
-        """Optimized semantic search with reduced top_k for CPU"""
-        if not self.index or not self.document_chunks:
+    def semantic_search_optimized(self, query: str, top_k: int = 10) -> List[DocumentChunk]:
+        """Enhanced semantic search with better relevance scoring"""
+        if not self.index or not self.document_chunks or not self.document_processed:
             return []
+        
         try:
+            # Create query embedding
             query_embedding = self.embedding_model.encode([query], normalize_embeddings=True)
-            scores, indices = self.index.search(query_embedding.astype('float32'), top_k)
-            results = []
+            
+            # Search for more candidates than needed
+            search_k = min(top_k * 3, len(self.document_chunks))
+            scores, indices = self.index.search(query_embedding.astype('float32'), search_k)
+            
+            # Enhanced scoring with keyword matching
+            query_lower = query.lower()
+            boosted_results = []
+            
+            # Define query-specific keywords for boosting
+            query_keywords = self._extract_query_keywords(query_lower)
+            
             for score, idx in zip(scores[0], indices[0]):
                 if 0 <= idx < len(self.document_chunks):
                     chunk = self.document_chunks[idx]
-                    chunk.context_window = self._get_context_window(idx)
-                    results.append(chunk)
-            return results
+                    chunk_text_lower = chunk.text.lower()
+                    
+                    # Base semantic score
+                    boosted_score = float(score)
+                    
+                    # Keyword matching boost
+                    keyword_matches = sum(1 for keyword in query_keywords if keyword in chunk_text_lower)
+                    boosted_score += keyword_matches * 0.2
+                    
+                    # Importance score boost
+                    boosted_score += chunk.importance_score * 0.1
+                    
+                    # Exact phrase matching boost
+                    if len(query_keywords) >= 2:
+                        query_phrases = [' '.join(query_keywords[i:i+2]) for i in range(len(query_keywords)-1)]
+                        phrase_matches = sum(1 for phrase in query_phrases if phrase in chunk_text_lower)
+                        boosted_score += phrase_matches * 0.3
+                    
+                    # Number/percentage matching boost
+                    query_numbers = re.findall(r'\d+', query_lower)
+                    chunk_numbers = re.findall(r'\d+', chunk_text_lower)
+                    number_matches = len(set(query_numbers).intersection(set(chunk_numbers)))
+                    boosted_score += number_matches * 0.15
+                    
+                    boosted_results.append((boosted_score, idx, chunk))
+            
+            # Sort by boosted score
+            boosted_results.sort(key=lambda x: x[0], reverse=True)
+            
+            # Select top results with context windows
+            top_chunks = []
+            for _, idx, chunk in boosted_results[:top_k]:
+                # Add context window to chunk
+                chunk.context_window = self._get_context_window(idx)
+                top_chunks.append(chunk)
+            
+            return top_chunks
+            
         except Exception as e:
             logger.error(f"Semantic search error: {e}")
             return []
     
+    def _extract_query_keywords(self, query_lower: str) -> List[str]:
+        """Extract relevant keywords from query for boosting"""
+        # Remove common question words
+        stop_words = {'what', 'is', 'are', 'the', 'a', 'an', 'how', 'when', 'where', 'why', 'which', 'who'}
+        
+        words = re.findall(r'\b\w+\b', query_lower)
+        keywords = [word for word in words if word not in stop_words and len(word) > 2]
+        
+        # Add compound terms
+        compound_terms = []
+        if 'grace' in keywords and 'period' in keywords:
+            compound_terms.append('grace period')
+        if 'waiting' in keywords and 'period' in keywords:
+            compound_terms.append('waiting period')
+        if 'sum' in keywords and 'insured' in keywords:
+            compound_terms.append('sum insured')
+        if 'room' in keywords and 'rent' in keywords:
+            compound_terms.append('room rent')
+        if 'co' in keywords and 'payment' in keywords:
+            compound_terms.append('co-payment')
+        
+        return keywords + compound_terms
+    
     def _get_context_window(self, chunk_idx: int, window_size: int = 1) -> str:
         """Get context from surrounding chunks"""
         context_parts = []
+        
+        # Add previous chunk context
         if chunk_idx > 0:
             prev_chunk = self.document_chunks[chunk_idx - 1]
-            context_parts.append(prev_chunk.text[-150:])  # Reduced context size
+            context_parts.append(prev_chunk.text[-200:])  # Last 200 chars
+        
+        # Add current chunk
         context_parts.append(self.document_chunks[chunk_idx].text)
+        
+        # Add next chunk context
         if chunk_idx < len(self.document_chunks) - 1:
             next_chunk = self.document_chunks[chunk_idx + 1]
-            context_parts.append(next_chunk.text[:150])  # Reduced context size
+            context_parts.append(next_chunk.text[:200])  # First 200 chars
+        
         return " ... ".join(context_parts)
     
-    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"""
+    def _build_optimized_context(self, question: str, chunks: List[DocumentChunk], max_length: int = 1000) -> str:
+        """Build optimized context from top chunks"""
+        if not chunks:
+            return ""
+        
         context_parts = []
         current_length = 0
+        
+        # Sort chunks by importance and relevance
         sorted_chunks = sorted(chunks, key=lambda x: x.importance_score, reverse=True)
+        
         for chunk in sorted_chunks:
-            chunk_text = chunk.context_window or chunk.text
+            chunk_text = chunk.context_window if chunk.context_window else chunk.text
             chunk_length = len(chunk_text)
+            
             if current_length + chunk_length <= max_length:
                 context_parts.append(chunk_text)
                 current_length += chunk_length
             else:
+                # Add partial chunk if there's space
                 remaining_space = max_length - current_length
-                if remaining_space > 100:
+                if remaining_space > 150:  # Only if meaningful space left
                     truncated = chunk_text[:remaining_space-3] + "..."
                     context_parts.append(truncated)
                 break
+        
         return " ".join(context_parts)
     
     def process_single_query_optimized(self, question: str) -> Dict[str, Any]:
-        """Optimized single query processing"""
-        if not self.index or not self.document_chunks:
+        """Process single query with enhanced accuracy"""
+        if not self.document_processed or not self.index or not self.document_chunks:
             return {
                 'answer': 'No document has been processed yet. Please upload a document first.',
                 'confidence': 0.0,
                 'reasoning': 'System requires document processing before answering queries.',
                 'processing_time': 0,
-                'token_count': 0,
                 'source_chunks': 0
             }
+        
         start_time = time.time()
         try:
-            top_chunks = self.semantic_search_optimized(question, top_k=3)  # REDUCED from 4 to 3
+            # Get relevant chunks
+            top_chunks = self.semantic_search_optimized(question, top_k=8)
+            
             if not top_chunks:
                 return {
                     'answer': 'No relevant information found in the document for this question.',
                     'confidence': 0.0,
-                    'reasoning': 'No semantically similar content found in document.',
+                    'reasoning': 'No semantically similar content found.',
                     'processing_time': time.time() - start_time,
-                    'token_count': 0,
                     'source_chunks': 0
                 }
+            
+            # Build comprehensive context
             context = self._build_optimized_context(question, top_chunks)
-            result = self.qa_system.generate_powerful_answer(question, context, top_chunks)
+            
+            # Log for debugging
+            logger.info(f"Question: '{question[:50]}...' | Chunks: {len(top_chunks)} | Context length: {len(context)}")
+            
+            # Generate answer
+            result = self.qa_system.generate_answer(question, context, top_chunks)
             return result
+            
         except Exception as e:
             logger.error(f"Query processing error: {e}")
             return {
@@ -659,77 +1002,98 @@ class HighPerformanceSystem:
                 'confidence': 0.0,
                 'reasoning': f'Processing error occurred: {str(e)}',
                 'processing_time': time.time() - start_time,
-                'token_count': 0,
                 'source_chunks': 0
             }
     
     def process_batch_queries_optimized(self, questions: List[str]) -> Dict[str, Any]:
-        """Optimized batch processing - RETURNS CLEAN ANSWERS ONLY"""
+        """Process multiple questions efficiently"""
         start_time = time.time()
         answers = []
+        
+        if not self.document_processed:
+            return {
+                'answers': ['No document has been processed yet. Please upload a document first.'] * len(questions),
+                'processing_time': time.time() - start_time
+            }
+        
         for i, question in enumerate(questions):
             logger.info(f"Processing question {i+1}/{len(questions)}: {question[:50]}...")
             result = self.process_single_query_optimized(question)
-            # FIXED: Only return the clean answer string for hackathon format
             answers.append(result['answer'])
+        
         total_time = time.time() - start_time
+        logger.info(f"Batch processing completed: {len(questions)} questions in {total_time:.2f}s")
+        
         return {
             'answers': answers,
             'processing_time': total_time
         }
 
-# Initialize the system
-high_performance_system = HighPerformanceSystem()
+# Initialize the enhanced system
+enhanced_system = EnhancedSingleDocumentSystem()
 
-def process_hackathon_submission(url, questions_text):
-    """Process hackathon submission format"""
-    if not url or not questions_text:
+def process_hackathon_submission(url_text, questions_text):
+    """Process hackathon submission - simplified for single document"""
+    if not url_text or not questions_text:
         return "Please provide both document URL and questions."
     
     try:
-        # Try to parse as JSON first
+        # Parse URL (single document)
+        url = url_text.strip()
+        if url.startswith('[') and url.endswith(']'):
+            urls = json.loads(url)
+            url = urls[0] if urls else ""
+        
+        if not url:
+            return "No valid URL found. Please provide a document URL."
+        
+        # Parse questions
         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 "No valid questions found. Please provide questions as JSON array or one per line."
         
         # Process document
-        doc_result = high_performance_system.process_document_optimized(url)
+        doc_result = enhanced_system.process_document_optimized(url)
         if not doc_result.get("success"):
             return f"Document processing failed: {doc_result.get('error')}"
         
         # Process questions
-        batch_result = high_performance_system.process_batch_queries_optimized(questions)
+        batch_result = enhanced_system.process_batch_queries_optimized(questions)
         
-        # Format as hackathon response - CLEAN JSON
+        # Format response for hackathon
         hackathon_response = {
-            "answers": batch_result['answers']  # Already clean strings
+            "answers": batch_result['answers']
         }
         
         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."
+        return f"JSON parsing error: {str(e)}. Please provide valid JSON or line-separated input."
     except Exception as e:
+        logger.error(f"Hackathon submission error: {e}")
         return f"Error processing submission: {str(e)}"
 
-def process_single_question(url, question):
+def process_single_question(url_text, question):
     """Process single question with detailed response"""
-    if not url or not question:
+    if not url_text or not question:
         return "Please provide both document URL and question."
     
     try:
+        url = url_text.strip()
+        if not url:
+            return "No valid URL found. Please provide a document URL."
+        
         # Process document
-        doc_result = high_performance_system.process_document_optimized(url)
+        doc_result = enhanced_system.process_document_optimized(url)
         if not doc_result.get("success"):
             return f"Document processing failed: {doc_result.get('error')}"
         
         # Process single question
-        result = high_performance_system.process_single_query_optimized(question)
+        result = enhanced_system.process_single_query_optimized(question)
         
         # Format detailed response
         detailed_response = {
@@ -740,290 +1104,181 @@ def process_single_question(url, question):
             "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"
-                }
+                "total_chunks": doc_result.get('total_chunks', 0),
+                "document_pages": doc_result.get('total_pages', 0),
+                "document_words": doc_result.get('total_words', 0)
             }
         }
         
         return json.dumps(detailed_response, indent=2)
         
     except Exception as e:
+        logger.error(f"Single question processing error: {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)
+# Wrapper functions for Gradio
+def hackathon_wrapper(url_text, questions_text):
+    return process_hackathon_submission(url_text, questions_text)
 
-def single_query_wrapper(url, question):
-    return process_single_question(url, question)
+def single_query_wrapper(url_text, question):
+    return process_single_question(url_text, question)
 
-# --- Gradio Interface (CPU-Optimized) ---
+# Simplified Gradio Interface
 with gr.Blocks(
     theme=gr.themes.Soft(
-        primary_hue="indigo",
-        secondary_hue="blue",
+        primary_hue="blue",
+        secondary_hue="indigo",
         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;
-        }
-        
         .gradio-container { 
             background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
             min-height: 100vh;
         }
         
         .main-content {
-            background: var(--card-background);
-            border-radius: var(--border-radius);
-            box-shadow: var(--shadow-lg);
+            background: white;
+            border-radius: 15px;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
             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%);
+            padding: 2rem;
+            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 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-size: 2.5rem; 
             font-weight: 800; 
-            margin-bottom: 0.75rem;
-            position: relative;
-            z-index: 2;
+            margin-bottom: 0.5rem;
             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-size: 1.1rem; 
+            opacity: 0.9; 
             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);
+        .content-section {
             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;
+            color: #4f46e5;
+            font-size: 1.4rem;
             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);
+            margin-bottom: 1rem;
         }
         
         .gr-button {
-            border-radius: var(--border-radius-sm) !important;
+            border-radius: 8px !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;
+            border-radius: 8px !important;
+            border: 2px solid #e2e8f0 !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 */
+            border-color: #4f46e5 !important;
         }
     """
 ) as demo:
 
-    # --- 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>
+            <h1>🎯 Single Document QA System</h1>
+            <p>Optimized for Accurate Insurance Document Analysis</p>
         </div>
         """)
 
-        # --- Main Content Area ---
         with gr.Row():
             
-            # --- Left Column: Inputs ---
-            with gr.Column(scale=1):
-                with gr.Column(elem_classes="input-container"):
-                    with gr.Tabs():
+            with gr.Column(scale=1, elem_classes="content-section"):
+                with gr.Tabs():
+                    
+                    with gr.Tab("🚀 Hackathon Mode", id=0):
+                        gr.HTML('<h3 class="section-title">📄 Document Analysis</h3>')
+                        
+                        hack_url = gr.Textbox(
+                            label="📄 Document URL",
+                            placeholder="https://example.com/insurance-policy.pdf",
+                            lines=2,
+                            info="Enter single document URL (PDF or DOCX format)"
+                        )
+                        
+                        hack_questions = gr.Textbox(
+                            label="❓ Questions",
+                            placeholder='["What is the grace period?", "Is maternity covered?"]',
+                            lines=6,
+                            info="Enter questions as JSON array or one per line"
+                        )
+                        
+                        with gr.Row():
+                            hack_clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+                            hack_submit_btn = gr.Button("🚀 Process Questions", variant="primary")
+                        
+                    with gr.Tab("🔍 Single Query", id=1):
+                        gr.HTML('<h3 class="section-title">🔍 Detailed Analysis</h3>')
+                        
+                        single_url = gr.Textbox(
+                            label="📄 Document URL",
+                            placeholder="https://example.com/insurance-policy.pdf",
+                            lines=2,
+                            info="Enter document URL for analysis"
+                        )
                         
-                        # --- 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")
+                        single_question = gr.Textbox(
+                            label="❓ Your Question",
+                            placeholder="What is the waiting period for pre-existing diseases?",
+                            lines=3,
+                            info="Ask a specific question about the document"
+                        )
+                        
+                        with gr.Row():
+                            single_clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+                            single_submit_btn = gr.Button("🔍 Get Answer", variant="primary")
 
-            # --- 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
-                            )
+            with gr.Column(scale=2, elem_classes="content-section"):
+                gr.HTML('<h3 class="section-title">📊 Results</h3>')
+                
+                with gr.Tabs():
+                    with gr.Tab("✅ Hackathon Results", id=2):
+                        hack_output = gr.Textbox(
+                            label="📊 JSON Response",
+                            lines=25,
+                            interactive=False,
+                            show_copy_button=True
+                        )
+                        
+                    with gr.Tab("🔍 Detailed Results", id=3):
+                        single_output = gr.Textbox(
+                            label="📋 Comprehensive Response",
+                            lines=25,
+                            interactive=False,
+                            show_copy_button=True
+                        )
 
-    
-    # Hackathon Tab Logic
+    # Event handlers
     hack_submit_btn.click(
         fn=hackathon_wrapper,
         inputs=[hack_url, hack_questions],
-        outputs=[hack_output]
+        outputs=[hack_output],
+        concurrency_limit=4
     )
     
     hack_clear_btn.click(
@@ -1031,11 +1286,11 @@ with gr.Blocks(
         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]
+        outputs=[single_output],
+        concurrency_limit=4
     )
     
     single_clear_btn.click(
@@ -1043,18 +1298,17 @@ with gr.Blocks(
         outputs=[single_url, single_question, single_output]
     )
 
-# Queue for better performance on Spaces
-demo.queue(max_size=5)
+# Configure for deployment
+demo.queue(max_size=20)
 
-# For Hugging Face Spaces deployment - mount the FastAPI app with Gradio
+# Mount Gradio on FastAPI
 app = gr.mount_gradio_app(api_app, demo, path="/")
 
-# For local development only
 if __name__ == "__main__":
-    # This will be ignored on Spaces - Spaces auto-detects and launches Gradio apps
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
-        show_error=True
+        show_error=True,
+        max_threads=10
     )