Delete app.py

app.py

@@ -1,1341 +0,0 @@
-import os
-import sys
-import json
-import logging
-import warnings
-from pathlib import Path
-from typing import List, Dict, Any, Optional, Tuple
-import hashlib
-import pickle
-from datetime import datetime
-import time
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
-
-# Suppress warnings for cleaner output
-warnings.filterwarnings("ignore")
-
-# Core dependencies
-import gradio as gr
-import numpy as np
-import pandas as pd
-from sentence_transformers import SentenceTransformer
-import faiss
-import torch
-from transformers import (
-    AutoTokenizer, 
-    AutoModelForCausalLM, 
-    BitsAndBytesConfig,
-    pipeline
-)
-
-# Document processing
-from llama_index.core import Document, VectorStoreIndex, Settings
-from llama_index.core.node_parser import SentenceSplitter
-from llama_index.vector_stores.faiss import FaissVectorStore
-from llama_index.embeddings.huggingface import HuggingFaceEmbedding
-from llama_index.core import StorageContext
-
-# PDF processing
-from unstructured.partition.pdf import partition_pdf
-from llama_index.core.schema import Document as LlamaDocument
-
-
-# Medical knowledge validation
-import re
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-class MedicalFactChecker:
-    """Enhanced medical fact checker with faster validation"""
-    
-    def __init__(self):
-        self.medical_facts = self._load_medical_facts()
-        self.contraindications = self._load_contraindications()
-        self.dosage_patterns = self._compile_dosage_patterns()
-        self.definitive_patterns = [
-            re.compile(r, re.IGNORECASE) for r in [
-                r'always\s+(?:use|take|apply)',
-                r'never\s+(?:use|take|apply)',
-                r'will\s+(?:cure|heal|fix)',
-                r'guaranteed\s+to',
-                r'completely\s+(?:safe|effective)'
-            ]
-        ]
-        
-    def _load_medical_facts(self) -> Dict[str, Any]:
-        """Pre-loaded medical facts for Gaza context"""
-        return {
-            "burn_treatment": {
-                "cool_water": "Use clean, cool (not ice-cold) water for 10-20 minutes",
-                "no_ice": "Never apply ice directly to burns",
-                "clean_cloth": "Cover with clean, dry cloth if available"
-            },
-            "wound_care": {
-                "pressure": "Apply direct pressure to control bleeding",
-                "elevation": "Elevate injured limb if possible",
-                "clean_hands": "Clean hands before treating wounds when possible"
-            },
-            "infection_signs": {
-                "redness": "Increasing redness around wound",
-                "warmth": "Increased warmth at wound site",
-                "pus": "Yellow or green discharge",
-                "fever": "Fever may indicate systemic infection"
-            }
-        }
-    
-    def _load_contraindications(self) -> Dict[str, List[str]]:
-        """Pre-loaded contraindications for common treatments"""
-        return {
-            "aspirin": ["children under 16", "bleeding disorders", "stomach ulcers"],
-            "ibuprofen": ["kidney disease", "heart failure", "stomach bleeding"],
-            "hydrogen_peroxide": ["deep wounds", "closed wounds", "eyes"],
-            "tourniquets": ["non-life-threatening bleeding", "without proper training"]
-        }
-    
-    def _compile_dosage_patterns(self) -> List[re.Pattern]:
-        """Pre-compiled dosage patterns"""
-        patterns = [
-            r'\d+\s*mg\b',  # milligrams
-            r'\d+\s*g\b',   # grams
-            r'\d+\s*ml\b',  # milliliters
-            r'\d+\s*tablets?\b',  # tablets
-            r'\d+\s*times?\s+(?:per\s+)?day\b',  # frequency
-            r'every\s+\d+\s+hours?\b'  # intervals
-        ]
-        return [re.compile(pattern, re.IGNORECASE) for pattern in patterns]
-    
-    def check_medical_accuracy(self, response: str, context: str) -> Dict[str, Any]:
-        """Enhanced medical accuracy check with Gaza-specific considerations"""
-        issues = []
-        warnings = []
-        accuracy_score = 0.0
-        
-        # Check for contraindications (faster keyword matching)
-        response_lower = response.lower()
-        for medication, contra_list in self.contraindications.items():
-            if medication in response_lower:
-                for contra in contra_list:
-                    if any(word in response_lower for word in contra.split()):
-                        issues.append(f"Potential contraindication: {medication} with {contra}")
-                        accuracy_score -= 0.3
-                        break
-        
-        # Context alignment using Jaccard similarity
-        if context:
-            resp_words = set(response_lower.split())
-            ctx_words = set(context.lower().split())
-            context_similarity = len(resp_words & ctx_words) / len(resp_words | ctx_words) if ctx_words else 0.0
-            if context_similarity < 0.5:  # Lowered threshold for Gaza context
-                warnings.append(f"Low context similarity: {context_similarity:.2f}")
-                accuracy_score -= 0.1
-        else:
-            context_similarity = 0.0
-        
-        # Gaza-specific resource checks
-        gaza_resources = ["clean water", "sterile", "hospital", "ambulance", "electricity"]
-        if any(resource in response_lower for resource in gaza_resources):
-            warnings.append("Consider resource limitations in Gaza context")
-            accuracy_score -= 0.05
-        
-        # Unsupported claims check
-        for pattern in self.definitive_patterns:
-            if pattern.search(response):
-                issues.append(f"Unsupported definitive claim detected")
-                accuracy_score -= 0.4
-                break
-        
-        # Dosage validation
-        for pattern in self.dosage_patterns:
-            if pattern.search(response):
-                warnings.append("Dosage detected - verify with professional")
-                accuracy_score -= 0.1
-                break
-        
-        confidence_score = max(0.0, min(1.0, 0.8 + accuracy_score))
-        
-        return {
-            "confidence_score": confidence_score,
-            "issues": issues,
-            "warnings": warnings,
-            "context_similarity": context_similarity,
-            "is_safe": len(issues) == 0 and confidence_score > 0.5
-        }
-
-class EnhancedGazaKnowledgeBase:
-    """Handles mismatched index/chunks by loading only matching pairs"""
-    
-    def __init__(self, data_dir: str = "./data"):
-        self.data_dir = Path(data_dir)
-        self.vector_store = None
-        self.index = None
-        self.text_chunks = []
-        self.chunk_metadata = []
-
-    def initialize(self):
-        """Loads available data with mismatch handling"""
-        try:
-            # 1. Load FAISS index
-            faiss_path = self.data_dir / "index.faiss"
-            if not faiss_path.exists():
-                raise FileNotFoundError(f"Missing FAISS index at {faiss_path}")
-            
-            faiss_index = faiss.read_index(str(faiss_path))
-            self.vector_store = FaissVectorStore(faiss_index=faiss_index)
-            vector_count = faiss_index.ntotal
-
-            # 2. Load available chunks
-            chunks_path = self.data_dir / "chunks.txt"
-            if not chunks_path.exists():
-                raise FileNotFoundError(f"Missing text chunks at {chunks_path}")
-            
-            with open(chunks_path, 'r', encoding='utf-8') as f:
-                all_chunks = [line.strip() for line in f if line.strip()]
-            
-            # 3. Handle mismatch by taking first N chunks
-            if len(all_chunks) != vector_count:
-                logger.warning(
-                    f"Using first {vector_count}/{len(all_chunks)} chunks "
-                    f"to match index size"
-                )
-                self.text_chunks = all_chunks[:vector_count]
-            else:
-                self.text_chunks = all_chunks
-
-            # 4. Create index structure
-            self.index = VectorStoreIndex.from_documents(
-                [Document(text="dummy")],  # Placeholder
-                storage_context=StorageContext.from_defaults(
-                    vector_store=self.vector_store
-                ),
-                embed_model=None  # Skip re-embedding
-            )
-            
-            logger.info(f"Loaded {len(self.text_chunks)} chunks with {vector_count} vectors")
-
-        except Exception as e:
-            logger.error(f"Initialization failed: {str(e)}")
-            raise
-
-            
-    def search(self, query: str, k: int = 5) -> List[Dict[str, Any]]:
-        """Search using existing embeddings"""
-        if not self.index:
-            raise RuntimeError("Index not initialized")
-        
-        # Get raw FAISS results
-        query_embedding = self._embed_query(query)
-        distances, indices = self.vector_store.index.search(
-            np.array([query_embedding]), k
-        )
-        
-        # Map to text chunks
-        results = []
-        for i, idx in enumerate(indices[0]):
-            if idx >= 0:  # FAISS returns -1 for invalid indices
-                results.append({
-                    "text": self.text_chunks[idx],
-                    "metadata": self.chunk_metadata[idx] if idx < len(self.chunk_metadata) else {},
-                    "score": float(distances[0][i])
-                })
-        return results
-
-    def _embed_query(self, query: str) -> np.ndarray:
-        """Embed queries using the same model used for index"""
-        # Use a simple sentence transformer if needed
-        model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
-        return model.encode(query)
-        
-
-    def _load_vector_store(self):
-        """Load existing vector store with error handling"""
-        try:
-            faiss_index = faiss.read_index(str(self.index_path / "index.faiss"))
-            vector_store = FaissVectorStore(faiss_index=faiss_index)
-
-            storage_context = StorageContext.from_defaults(
-                vector_store=vector_store,
-                persist_dir=str(self.index_path)
-            )
-
-            self.index = VectorStoreIndex.load(storage_context=storage_context)
-
-            metadata_path = self.index_path / "metadata.pkl"
-            if metadata_path.exists():
-                with open(metadata_path, 'rb') as f:
-                    self.chunk_metadata = pickle.load(f)
-
-            logger.info(f"Loaded existing vector store with {len(self.chunk_metadata)} chunks")
-
-        except Exception as e:
-            logger.error(f"Error loading vector store: {e}")
-            self._create_vector_store()
-
-
-    
-    def search(self, query: str, k: int = 5) -> List[Dict[str, Any]]:
-        """Enhanced search with better error handling and result processing"""
-        if not self.index:
-            logger.warning("Index not available for search")
-            return []
-            
-        try:
-            retriever = self.index.as_retriever(similarity_top_k=k)
-            results = retriever.retrieve(query)
-            
-            # FIX: Handle the tuple object error by properly extracting node and score
-            processed_results = []
-            for result in results:
-                try:
-                    # Handle both tuple and direct node results
-                    if isinstance(result, tuple):
-                        node, score = result
-                    else:
-                        node = result
-                        score = getattr(result, 'score', 0.0)
-                    
-                    # Extract text safely
-                    text = getattr(node, 'text', str(node))
-                    source = node.metadata.get("source", "unknown") if hasattr(node, 'metadata') else "unknown"
-                    
-                    processed_results.append({
-                        "text": text,
-                        "source": source,
-                        "score": float(score) if score is not None else 0.0,
-                        "medical_priority": self._assess_priority(text)
-                    })
-                except Exception as e:
-                    logger.error(f"Error processing search result: {e}")
-                    continue
-            
-            # Sort by score (higher is better)
-            processed_results.sort(key=lambda x: x['score'], reverse=True)
-            
-            logger.info(f"Search returned {len(processed_results)} results for query: {query[:50]}...")
-            return processed_results
-            
-        except Exception as e:
-            logger.error(f"Error during search: {e}")
-            return []
-    
-    def _assess_priority(self, text: str) -> str:
-        """Enhanced medical priority assessment"""
-        text_lower = text.lower()
-        
-        # Check priorities in order of importance
-        priority_order = ["emergency", "trauma", "gaza_specific", "infectious", "chronic"]
-        
-        for priority in priority_order:
-            keywords = self.medical_priorities.get(priority, [])
-            if any(re.search(keyword, text_lower) for keyword in keywords):
-                return priority
-        
-        return "general"
-
-
-
-
-class EnhancedGazaRAGSystem:
-    """Enhanced RAG system with better performance and error handling"""
-    
-    def __init__(self):
-        self.knowledge_base = EnhancedGazaKnowledgeBase()
-        self.fact_checker = MedicalFactChecker()
-        self.llm = None
-        self.tokenizer = None
-        self.system_prompt = self._create_system_prompt()
-        self.generation_pipeline = None
-        self.response_cache = {}  # Simple response caching
-        self.executor = ThreadPoolExecutor(max_workers=2)  # For async processing
-        
-    def initialize(self):
-        """Initialize the RAG system by initializing the knowledge base"""
-        self.knowledge_base.initialize()
-        logger.info("Enhanced Gaza RAG System initialized")
-
-    def _initialize_llm(self):
-        """Enhanced LLM initialization with better error handling"""
-        if self.llm is not None:
-            return
-            
-        model_name = "microsoft/Phi-3-mini-4k-instruct"
-        try:
-            logger.info(f"Loading LLM: {model_name}")
-            
-            # Enhanced quantization configuration
-            quantization_config = BitsAndBytesConfig(
-                load_in_4bit=True,
-                bnb_4bit_use_double_quant=True,
-                bnb_4bit_quant_type="nf4",
-                bnb_4bit_compute_dtype=torch.float16,
-            )
-
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                model_name,
-                trust_remote_code=True,
-                padding_side="left"
-            )
-            
-            if self.tokenizer.pad_token is None:
-                self.tokenizer.pad_token = self.tokenizer.eos_token
-            
-            self.llm = AutoModelForCausalLM.from_pretrained(
-                model_name,
-                quantization_config=quantization_config,
-                device_map="auto",
-                trust_remote_code=True,
-                torch_dtype=torch.float16,
-                low_cpu_mem_usage=True
-            )
-            
-            self.generation_pipeline = pipeline(
-                "text-generation",
-                model=self.llm,
-                tokenizer=self.tokenizer,
-                device_map="auto",
-                torch_dtype=torch.float16,
-                return_full_text=False
-            )
-            
-            logger.info("LLM loaded successfully")
-            
-        except Exception as e:
-            logger.error(f"Error loading primary model: {e}")
-            self._initialize_fallback_llm()
-
-    def _initialize_fallback_llm(self):
-        """Enhanced fallback model with better error handling"""
-        try:
-            logger.info("Loading fallback model...")
-            
-            fallback_model = "microsoft/DialoGPT-small"
-            self.tokenizer = AutoTokenizer.from_pretrained(fallback_model)
-            self.llm = AutoModelForCausalLM.from_pretrained(
-                fallback_model,
-                torch_dtype=torch.float32,
-                low_cpu_mem_usage=True
-            )
-            
-            if self.tokenizer.pad_token is None:
-                self.tokenizer.pad_token = self.tokenizer.eos_token
-            
-            self.generation_pipeline = pipeline(
-                "text-generation",
-                model=self.llm,
-                tokenizer=self.tokenizer,
-                return_full_text=False
-            )
-            
-            logger.info("Fallback model loaded successfully")
-            
-        except Exception as e:
-            logger.error(f"Fallback model failed: {e}")
-            self.llm = None
-            self.generation_pipeline = None
-    
-    def _create_system_prompt(self) -> str:
-        """Enhanced system prompt for Gaza context"""
-        return """You are a medical AI assistant specifically designed for Gaza healthcare workers operating under siege conditions. 
-
-CRITICAL GUIDELINES:
-- Provide practical first aid guidance considering limited resources (water, electricity, medical supplies)
-- Always prioritize patient safety and recommend professional medical help when available
-- Consider Gaza's specific challenges: blockade, limited hospitals, frequent power outages
-- Suggest alternative treatments when standard medical supplies are unavailable
-- Never provide definitive diagnoses - only supportive care guidance
-- Be culturally sensitive and aware of the humanitarian crisis context
-
-RESOURCE CONSTRAINTS TO CONSIDER:
-- Limited clean water availability
-- Frequent electricity outages
-- Restricted medical supply access
-- Overwhelmed healthcare facilities
-- Limited transportation for medical emergencies
-
-Provide clear, actionable advice while emphasizing the need for professional medical care when possible."""
-    
-    async def generate_response_async(self, query: str, progress_callback=None) -> Dict[str, Any]:
-        """Async response generation with progress tracking"""
-        start_time = time.time()
-        
-        if progress_callback:
-            progress_callback(0.1, "Checking cache...")
-        
-        # Check cache first
-        query_hash = hashlib.md5(query.encode()).hexdigest()
-        if query_hash in self.response_cache:
-            cached_response = self.response_cache[query_hash]
-            cached_response["cached"] = True
-            cached_response["response_time"] = 0.1
-            if progress_callback:
-                progress_callback(1.0, "Retrieved from cache!")
-            return cached_response
-        
-        try:
-            if progress_callback:
-                progress_callback(0.2, "Initializing LLM...")
-            
-            # Initialize LLM only when needed
-            if self.llm is None:
-                await asyncio.get_event_loop().run_in_executor(
-                    self.executor, self._initialize_llm
-                )
-            
-            if progress_callback:
-                progress_callback(0.4, "Searching knowledge base...")
-                
-            # Enhanced knowledge retrieval
-            search_results = await asyncio.get_event_loop().run_in_executor(
-                self.executor, self.knowledge_base.search, query, 3
-            )
-            
-            if progress_callback:
-                progress_callback(0.6, "Preparing context...")
-            
-            context = self._prepare_context(search_results)
-            
-            if progress_callback:
-                progress_callback(0.8, "Generating response...")
-            
-            # Generate response
-            response = await asyncio.get_event_loop().run_in_executor(
-                self.executor, self._generate_response, query, context
-            )
-            
-            if progress_callback:
-                progress_callback(0.9, "Validating safety...")
-            
-            # Enhanced safety check
-            safety_check = self.fact_checker.check_medical_accuracy(response, context)
-            
-            # Prepare final response
-            final_response = self._prepare_final_response(
-                response, 
-                search_results, 
-                safety_check,
-                time.time() - start_time
-            )
-            
-            # Cache the response (limit cache size)
-            if len(self.response_cache) < 100:
-                self.response_cache[query_hash] = final_response
-            
-            if progress_callback:
-                progress_callback(1.0, "Complete!")
-            
-            return final_response
-            
-        except Exception as e:
-            logger.error(f"Error generating response: {e}")
-            if progress_callback:
-                progress_callback(1.0, f"Error: {str(e)}")
-            return self._create_error_response(str(e))
-    
-    
-    
-    
-    def _generate_response(self, query: str, context: str) -> str:
-        """Enhanced response generation using model.generate() to avoid DynamicCache errors"""
-        if self.llm is None or self.tokenizer is None:
-            return self._generate_fallback_response(query, context)
-
-        # Build prompt with Gaza-specific context
-        prompt = f"""{self.system_prompt}
-        MEDICAL KNOWLEDGE CONTEXT:
-        {context}
-        PATIENT QUESTION: {query}
-        RESPONSE (provide practical, Gaza-appropriate medical guidance):"""
-
-        try:
-            # Tokenize and move to correct device
-            inputs = self.tokenizer(prompt, return_tensors="pt").to(self.llm.device)
-
-            # Generate the response
-            outputs = self.llm.generate(
-                **inputs,
-                max_new_tokens=800,
-                temperature=0.5,
-                pad_token_id=self.tokenizer.eos_token_id,
-                do_sample=True,
-                repetition_penalty=1.15,
-            )
-
-            # Decode and clean up
-            response_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-            lines = response_text.split('\n')
-            unique_lines = []
-            for line in lines:
-                line = line.strip()
-                if line and line not in unique_lines:
-                    unique_lines.append(line)
-            return '\n'.join(unique_lines)
-
-        except Exception as e:
-            logger.error(f"Error in LLM generate(): {e}")
-            return self._generate_fallback_response(query, context)
-
-
-        # Decode and clean up
-        response_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-        lines = response_text.split('\n')
-        unique_lines = []
-        for line in lines:
-            line = line.strip()
-            if line and line not in unique_lines:
-                unique_lines.append(line)
-        return '\n'.join(unique_lines)
-
-
-    
-    
-    def _prepare_context(self, search_results: List[Dict[str, Any]]) -> str:
-        """Enhanced context preparation with better formatting"""
-        if not search_results:
-            return "No specific medical guidance found in knowledge base. Provide general first aid principles."
-        
-        context_parts = []
-        for i, result in enumerate(search_results, 1):
-            source = result.get('source', 'unknown')
-            text = result.get('text', '')
-            priority = result.get('medical_priority', 'general')
-            
-            # Truncate long text but preserve important information
-            if len(text) > 400:
-                text = text[:400] + "..."
-            
-            context_parts.append(f"[Source {i}: {source} - Priority: {priority}]\n{text}")
-        
-        return "\n\n".join(context_parts)
-    
-    def _generate_response(self, query: str, context: str) -> str:
-        """Enhanced response generation with better prompting"""
-        if not self.generation_pipeline:
-            return self._generate_fallback_response(query, context)
-        
-        # Enhanced prompt structure
-        prompt = f"""{self.system_prompt}
-
-MEDICAL KNOWLEDGE CONTEXT:
-{context}
-
-PATIENT QUESTION: {query}
-
-RESPONSE (provide practical, Gaza-appropriate medical guidance):"""
-        
-        try:
-            # Enhanced generation parameters
-            response = self.generation_pipeline(
-                prompt,
-                max_new_tokens=300,  # Increased for more detailed responses
-                temperature=0.2,     # Lower for more consistent medical advice
-                do_sample=True,
-                pad_token_id=self.tokenizer.eos_token_id,
-                repetition_penalty=1.15,
-                truncation=True,
-                num_return_sequences=1
-            )
-            
-            if response and len(response) > 0:
-                generated_text = response[0]['generated_text']
-                # Clean up the response
-                generated_text = generated_text.strip()
-                
-                # Remove any repetitive patterns
-                lines = generated_text.split('\n')
-                unique_lines = []
-                for line in lines:
-                    if line.strip() and line.strip() not in unique_lines:
-                        unique_lines.append(line.strip())
-                
-                return '\n'.join(unique_lines)
-            else:
-                return self._generate_fallback_response(query, context)
-                
-        except Exception as e:
-            logger.error(f"Error in LLM generation: {e}")
-            return self._generate_fallback_response(query, context)
-    
-    def _generate_fallback_response(self, query: str, context: str) -> str:
-        """Enhanced fallback response with Gaza-specific guidance"""
-        gaza_guidance = {
-            "burn": "For burns: Use clean, cool water if available. If water is scarce, use clean cloth. Avoid ice. Seek medical help urgently.",
-            "bleeding": "For bleeding: Apply direct pressure with clean cloth. Elevate if possible. If severe, seek immediate medical attention.",
-            "wound": "For wounds: Clean hands if possible. Apply pressure to stop bleeding. Cover with clean material. Watch for infection signs.",
-            "infection": "Signs of infection: Redness, warmth, swelling, pus, fever. Seek medical care immediately if available.",
-            "pain": "For pain management: Rest, elevation, cold/warm compress as appropriate. Avoid aspirin in children."
-        }
-        
-        query_lower = query.lower()
-        for condition, guidance in gaza_guidance.items():
-            if condition in query_lower:
-                return f"{guidance}\n\nContext from medical sources:\n{context[:200]}..."
-        
-        return f"Medical guidance for: {query}\n\nGeneral advice: Prioritize safety, seek professional help when available, consider resource limitations in Gaza.\n\nRelevant information:\n{context[:300]}..."
-    
-    def _prepare_final_response(
-        self, 
-        response: str, 
-        search_results: List[Dict[str, Any]], 
-        safety_check: Dict[str, Any],
-        response_time: float
-    ) -> Dict[str, Any]:
-        """Enhanced final response preparation with more metadata"""
-        
-        # Add safety warnings if needed
-        if not safety_check["is_safe"]:
-            response = f"⚠️ MEDICAL CAUTION: {response}\n\n🚨 Please verify this guidance with a medical professional when possible."
-        
-        # Add Gaza-specific disclaimer
-        response += "\n\n📍 Gaza Context: This guidance considers resource limitations. Adapt based on available supplies and seek professional medical care when accessible."
-        
-        # Extract unique sources
-        sources = list(set(res.get("source", "unknown") for res in search_results)) if search_results else []
-        
-        # Calculate confidence based on multiple factors
-        base_confidence = safety_check.get("confidence_score", 0.5)
-        context_bonus = 0.1 if search_results else 0.0
-        safety_penalty = 0.2 if not safety_check.get("is_safe", True) else 0.0
-        
-        final_confidence = max(0.0, min(1.0, base_confidence + context_bonus - safety_penalty))
-        
-        return {
-            "response": response,
-            "confidence": final_confidence,
-            "sources": sources,
-            "search_results_count": len(search_results),
-            "safety_issues": safety_check.get("issues", []),
-            "safety_warnings": safety_check.get("warnings", []),
-            "response_time": round(response_time, 2),
-            "timestamp": datetime.now().isoformat()[:19],
-            "cached": False
-        }
-    
-    def _create_error_response(self, error_msg: str) -> Dict[str, Any]:
-        """Enhanced error response with helpful information"""
-        return {
-            "response": f"⚠️ System Error: Unable to process your medical query at this time.\n\nError: {error_msg}\n\n🚨 For immediate medical emergencies, seek professional help directly.\n\n📞 Gaza Emergency Numbers:\n- Palestinian Red Crescent: 101\n- Civil Defense: 102",
-            "confidence": 0.0,
-            "sources": [],
-            "search_results_count": 0,
-            "safety_issues": ["System error occurred"],
-            "safety_warnings": ["Unable to validate medical accuracy"],
-            "response_time": 0.0,
-            "timestamp": datetime.now().isoformat()[:19],
-            "cached": False,
-            "error": True
-        }
-
-# Global system instance
-enhanced_rag_system = None
-
-def initialize_enhanced_system():
-    """Initialize enhanced system with better error handling"""
-    global enhanced_rag_system
-    if enhanced_rag_system is None:
-        try:
-            enhanced_rag_system = EnhancedGazaRAGSystem()
-            enhanced_rag_system.initialize()
-            logger.info("Enhanced Gaza RAG System initialized successfully")
-        except Exception as e:
-            logger.error(f"Failed to initialize enhanced system: {e}")
-            raise
-    return enhanced_rag_system
-
-def process_medical_query_with_progress(query: str, progress=gr.Progress()) -> Tuple[str, str, str]:
-    """Enhanced query processing with detailed progress tracking and status updates"""
-    if not query.strip():
-        return "Please enter a medical question.", "", "⚠️ No query provided"
-    
-    try:
-        # Initialize system with progress
-        progress(0.05, desc="🔧 Initializing system...")
-        system = initialize_enhanced_system()
-        
-        # Create async event loop for progress tracking
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        
-        def progress_callback(value, desc):
-            progress(value, desc=desc)
-        
-        try:
-            # Run async generation with progress
-            result = loop.run_until_complete(
-                system.generate_response_async(query, progress_callback)
-            )
-        finally:
-            loop.close()
-        
-        # Prepare response with enhanced metadata
-        response = result["response"]
-        
-        # Prepare detailed metadata
-        metadata_parts = [
-            f"🎯 Confidence: {result['confidence']:.1%}",
-            f"⏱️ Response: {result['response_time']}s",
-            f"📚 Sources: {result['search_results_count']} found"
-        ]
-        
-        if result.get('cached'):
-            metadata_parts.append("💾 Cached")
-        
-        if result.get('sources'):
-            metadata_parts.append(f"📖 Refs: {', '.join(result['sources'][:2])}")
-        
-        metadata = " | ".join(metadata_parts)
-        
-        # Prepare status with warnings/issues
-        status_parts = []
-        if result.get('safety_warnings'):
-            status_parts.append(f"⚠️ {len(result['safety_warnings'])} warnings")
-        if result.get('safety_issues'):
-            status_parts.append(f"🚨 {len(result['safety_issues'])} issues")
-        if not status_parts:
-            status_parts.append("✅ Safe response")
-        
-        status = " | ".join(status_parts)
-        
-        return response, metadata, status
-        
-    except Exception as e:
-        logger.error(f"Error processing query: {e}")
-        error_response = f"⚠️ Error processing your query: {str(e)}\n\n🚨 For medical emergencies, seek immediate professional help."
-        error_metadata = f"❌ Error at {datetime.now().strftime('%H:%M:%S')}"
-        error_status = "🚨 System error occurred"
-        return error_response, error_metadata, error_status
-
-
-def create_advanced_gradio_interface():
-    """Create advanced Gradio interface with modern design and enhanced UX"""
-    
-    # Advanced CSS with medical theme and animations
-    css = """
-    @import url('https://fonts.googleapis.com/css2?family=Love+Ya+Like+A+Sister&display=swap');
-
-    * {
-        font-family: 'Love Ya Like A Sister', cursive !important;
-    }
-
-    .gradio-container {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        min-height: 100vh;
-    }
-    
-    .main-container {
-        background: rgba(255, 255, 255, 0.95);
-        backdrop-filter: blur(10px);
-        border-radius: 20px;
-        padding: 30px;
-        margin: 20px;
-        box-shadow: 0 20px 40px rgba(0,0,0,0.1);
-        border: 1px solid rgba(255,255,255,0.2);
-    }
-    
-    .header-section {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        color: white;
-        border-radius: 15px;
-        padding: 25px;
-        margin-bottom: 25px;
-        text-align: center;
-        box-shadow: 0 10px 30px rgba(102, 126, 234, 0.3);
-    }
-    
-    .query-container {
-        background: linear-gradient(135deg, #f8f9ff 0%, #e8f2ff 100%);
-        border-radius: 15px;
-        padding: 20px;
-        margin: 15px 0;
-        border: 2px solid #667eea;
-        transition: all 0.3s ease;
-    }
-    
-    .query-container:hover {
-        transform: translateY(-2px);
-        box-shadow: 0 10px 25px rgba(102, 126, 234, 0.2);
-    }
-    
-    .query-input {
-        border: none !important;
-        background: white !important;
-        border-radius: 12px !important;
-        padding: 15px !important;
-        font-size: 16px !important;
-        box-shadow: 0 4px 15px rgba(0,0,0,0.1) !important;
-        transition: all 0.3s ease !important;
-    }
-    
-    .query-input:focus {
-        transform: scale(1.02) !important;
-        box-shadow: 0 8px 25px rgba(102, 126, 234, 0.3) !important;
-    }
-    
-    .response-container {
-        background: linear-gradient(135deg, #fff 0%, #f8f9ff 100%);
-        border-radius: 15px;
-        padding: 20px;
-        margin: 15px 0;
-        border: 2px solid #4CAF50;
-        min-height: 300px;
-    }
-    
-    .response-output {
-        border: none !important;
-        background: transparent !important;
-        font-size: 15px !important;
-        line-height: 1.7 !important;
-        color: #2c3e50 !important;
-    }
-    
-    .metadata-container {
-        background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%);
-        border-radius: 12px;
-        padding: 15px;
-        margin: 10px 0;
-        border-left: 5px solid #2196F3;
-    }
-    
-    .metadata-output {
-        border: none !important;
-        background: transparent !important;
-        font-size: 13px !important;
-        color: #1565c0 !important;
-        font-weight: 500 !important;
-    }
-    
-    .status-container {
-        background: linear-gradient(135deg, #e8f5e8 0%, #c8e6c9 100%);
-        border-radius: 12px;
-        padding: 15px;
-        margin: 10px 0;
-        border-left: 5px solid #4CAF50;
-    }
-    
-    .status-output {
-        border: none !important;
-        background: transparent !important;
-        font-size: 13px !important;
-        color: #2e7d32 !important;
-        font-weight: 500 !important;
-    }
-    
-    .submit-btn {
-        background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%) !important;
-        color: white !important;
-        border: none !important;
-        border-radius: 12px !important;
-        padding: 15px 30px !important;
-        font-size: 16px !important;
-        font-weight: 600 !important;
-        cursor: pointer !important;
-        transition: all 0.3s ease !important;
-        box-shadow: 0 6px 20px rgba(76, 175, 80, 0.3) !important;
-    }
-    
-    .submit-btn:hover {
-        transform: translateY(-3px) !important;
-        box-shadow: 0 10px 30px rgba(76, 175, 80, 0.4) !important;
-    }
-    
-    .clear-btn {
-        background: linear-gradient(135deg, #ff7043 0%, #ff5722 100%) !important;
-        color: white !important;
-        border: none !important;
-        border-radius: 12px !important;
-        padding: 15px 25px !important;
-        font-size: 14px !important;
-        font-weight: 500 !important;
-        transition: all 0.3s ease !important;
-    }
-    
-    .clear-btn:hover {
-        transform: translateY(-2px) !important;
-        box-shadow: 0 8px 20px rgba(255, 87, 34, 0.3) !important;
-    }
-    
-    .emergency-notice {
-        background: linear-gradient(135deg, #ffebee 0%, #ffcdd2 100%);
-        border: 2px solid #f44336;
-        border-radius: 15px;
-        padding: 20px;
-        margin: 20px 0;
-        color: #c62828;
-        font-weight: 600;
-        animation: pulse 2s infinite;
-    }
-    
-    @keyframes pulse {
-        0% { box-shadow: 0 0 0 0 rgba(244, 67, 54, 0.4); }
-        70% { box-shadow: 0 0 0 10px rgba(244, 67, 54, 0); }
-        100% { box-shadow: 0 0 0 0 rgba(244, 67, 54, 0); }
-    }
-    
-    .gaza-context {
-        background: linear-gradient(135deg, #e8f5e8 0%, #c8e6c9 100%);
-        border: 2px solid #4caf50;
-        border-radius: 15px;
-        padding: 20px;
-        margin: 20px 0;
-        color: #2e7d32;
-        font-weight: 500;
-    }
-    
-    .sidebar-container {
-        background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
-        border-radius: 15px;
-        padding: 20px;
-        margin: 10px 0;
-        border: 1px solid rgba(0,0,0,0.1);
-    }
-    
-    .example-container {
-        background: white;
-        border-radius: 12px;
-        padding: 20px;
-        margin: 15px 0;
-        box-shadow: 0 4px 15px rgba(0,0,0,0.1);
-    }
-    
-    .progress-container {
-        margin: 15px 0;
-        padding: 10px;
-        background: rgba(255,255,255,0.8);
-        border-radius: 10px;
-    }
-    
-    .footer-section {
-        background: linear-gradient(135deg, #37474f 0%, #263238 100%);
-        color: white;
-        border-radius: 15px;
-        padding: 20px;
-        margin-top: 30px;
-        text-align: center;
-    }
-
-    /* GLOBAL TEXT FIXES */
-.gradio-container, 
-.query-container, 
-.response-container, 
-.metadata-container, 
-.status-container {
-    color: white !important;
-}
-
-.query-input, 
-.response-output, 
-.metadata-output, 
-.status-output {
-    color: white !important;
-    background-color: rgba(0, 0, 0, 0.2) !important;
-}
-
-/* BANNER-INSPIRED PANEL BACKGROUNDS */
-.query-container,
-.response-container,
-.metadata-container,
-.status-container {
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
-    border: 2px solid #ffffff22 !important;
-    border-radius: 15px !important;
-    box-shadow: 0 10px 30px rgba(102, 126, 234, 0.3);
-}
-
-/* EXAMPLE SECTION BUTTON STYLING */
-.example-container .example {
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
-    color: white !important;
-    font-weight: 600 !important;
-    border-radius: 12px !important;
-    padding: 15px !important;
-    margin: 10px !important;
-    text-align: center !important;
-    box-shadow: 0 6px 20px rgba(0, 0, 0, 0.1);
-    transition: all 0.3s ease;
-    cursor: pointer;
-}
-
-.example-container .example:hover {
-    transform: scale(1.03);
-    box-shadow: 0 10px 30px rgba(102, 126, 234, 0.4);
-}
-
-/* MAKE HEADER + EXAMPLES MORE PROMINENT */
-.header-section {
-    color: white !important;
-    text-shadow: 0px 0px 6px rgba(0,0,0,0.4);
-}
-
-.example-container {
-    margin-top: -20px !important;
-}
-    """
-
-    with gr.Blocks(
-        css=css, 
-        title="🏥 Advanced Gaza First Aid Assistant",
-        theme=gr.themes.Soft(
-            primary_hue="blue",
-            secondary_hue="green",
-            neutral_hue="slate"
-        )
-    ) as interface:
-        
-        # Header Section
-        with gr.Row(elem_classes=["main-container"]):
-            gr.HTML("""
-            <div class="header-section">
-                <h1 style="margin: 0; font-size: 2.5em; font-weight: 700;">
-                    🏥 Advanced Gaza First Aid Assistant
-                </h1>
-                <h2 style="margin: 10px 0 0 0; font-size: 1.2em; font-weight: 400; opacity: 0.9;">
-                    AI-Powered Medical Guidance for Gaza Healthcare Workers
-                </h2>
-                <p style="margin: 15px 0 0 0; font-size: 1em; opacity: 0.8;">
-                    Enhanced with 768-dimensional medical embeddings • Advanced FAISS indexing • Real-time safety validation
-                </p>
-            </div>
-            """)
-        
-        # Main Interface
-        with gr.Row(elem_classes=["main-container"]):
-            with gr.Column(scale=2):
-                # Query Input Section
-                with gr.Group(elem_classes=["query-container"]):
-                    gr.Markdown("### 🩺 Medical Query Input")
-                    query_input = gr.Textbox(
-                        label="Describe your medical situation",
-                        placeholder="Enter your first aid question or describe the medical emergency...",
-                        lines=4,
-                        elem_classes=["query-input"]
-                    )
-                    
-                    with gr.Row():
-                        submit_btn = gr.Button(
-                            "🔍 Get Medical Guidance", 
-                            variant="primary",
-                            elem_classes=["submit-btn"],
-                            scale=3
-                        )
-                        clear_btn = gr.Button(
-                            "🗑️ Clear", 
-                            variant="secondary",
-                            elem_classes=["clear-btn"],
-                            scale=1
-                        )
-            
-            with gr.Column(scale=1):
-                # Sidebar with Quick Access
-                with gr.Group(elem_classes=["sidebar-container"]):
-                    gr.Markdown("""
-                    ### 🎯 Quick Access Guide
-                    
-                    **🚨 Emergency Priorities:**
-                    - Severe bleeding control
-                    - Burn treatment protocols  
-                    - Airway management
-                    - Trauma stabilization
-                    - Shock prevention
-                    
-                    **🏥 Gaza-Specific Scenarios:**
-                    - Limited water situations
-                    - Power outage medical care
-                    - Supply shortage alternatives
-                    - Mass casualty protocols
-                    - Improvised medical tools
-                    
-                    **📊 System Status:**
-                    - ✅ Enhanced embeddings active
-                    - ✅ Advanced indexing enabled
-                    - ✅ Safety validation online
-                    - ✅ Gaza context aware
-                    """)
-        
-        # Response Section
-        with gr.Row(elem_classes=["main-container"]):
-            with gr.Column():
-                # Main Response
-                with gr.Group(elem_classes=["response-container"]):
-                    gr.Markdown("### 🩹 Medical Guidance Response")
-                    response_output = gr.Textbox(
-                        label="AI Medical Guidance",
-                        lines=15,
-                        elem_classes=["response-output"],
-                        interactive=False,
-                        placeholder="Your medical guidance will appear here..."
-                    )
-                
-                # Metadata and Status
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        with gr.Group(elem_classes=["metadata-container"]):
-                            metadata_output = gr.Textbox(
-                                label="📊 Response Metadata",
-                                lines=2,
-                                elem_classes=["metadata-output"],
-                                interactive=False,
-                                placeholder="Response metadata will appear here..."
-                            )
-                    
-                    with gr.Column(scale=1):
-                        with gr.Group(elem_classes=["status-container"]):
-                            status_output = gr.Textbox(
-                                label="🛡️ Safety Status",
-                                lines=2,
-                                elem_classes=["status-output"],
-                                interactive=False,
-                                placeholder="Safety validation status will appear here..."
-                            )
-        
-        # Important Notices
-        with gr.Row(elem_classes=["main-container"]):
-            gr.HTML("""
-            <div class="emergency-notice">
-                <h3 style="margin: 0 0 10px 0;">🚨 CRITICAL EMERGENCY DISCLAIMER</h3>
-                <p style="margin: 0; font-size: 1.1em;">
-                    For life-threatening emergencies, seek immediate professional medical attention.<br>
-                    📞 <strong>Gaza Emergency Contacts:</strong> Palestinian Red Crescent (101) | Civil Defense (102)
-                </p>
-            </div>
-            """)
-        
-        with gr.Row(elem_classes=["main-container"]):
-            gr.HTML("""
-            <div class="gaza-context">
-                <h3 style="margin: 0 0 10px 0;">📍 Gaza Context Awareness</h3>
-                <p style="margin: 0; font-size: 1em;">
-                    This advanced AI system is specifically designed for Gaza's challenging conditions including 
-                    limited resources, frequent power outages, and restricted medical supply access. All guidance 
-                    considers these constraints and provides practical alternatives when standard treatments are unavailable.
-                </p>
-            </div>
-            """)
-        
-        # Examples Section
-        with gr.Row(elem_classes=["main-container"]):
-            with gr.Group(elem_classes=["example-container"]):
-                gr.Markdown("### 💡 Example Medical Scenarios")
-                
-                example_queries = [
-                    "How to treat severe burns when clean water is extremely limited?",
-                    "Managing gunshot wounds with only basic household supplies",
-                    "Recognizing and treating infection in wounds without antibiotics",
-                    "Emergency care for children during extended power outages",
-                    "Treating compound fractures without proper medical equipment",
-                    "Managing diabetic emergencies when insulin is unavailable",
-                    "Stopping arterial bleeding with improvised tourniquets",
-                    "Recognizing and treating shock in mass casualty situations",
-                    "Airway management for unconscious patients without equipment",
-                    "Preventing infection in surgical wounds during siege conditions"
-                ]
-                
-                gr.Examples(
-                    examples=example_queries,
-                    inputs=query_input,
-                    label="Click any example to try it:",
-                    examples_per_page=5
-                )
-        
-        # Event Handlers
-        submit_btn.click(
-            process_medical_query_with_progress,
-            inputs=query_input,
-            outputs=[response_output, metadata_output, status_output],
-            show_progress=True
-        )
-        
-        query_input.submit(
-            process_medical_query_with_progress,
-            inputs=query_input,
-            outputs=[response_output, metadata_output, status_output],
-            show_progress=True
-        )
-        
-        clear_btn.click(
-            lambda: ("", "", "", ""),
-            outputs=[query_input, response_output, metadata_output, status_output]
-        )
-        
-        # Footer
-        with gr.Row(elem_classes=["main-container"]):
-            gr.HTML("""
-            <div class="footer-section">
-                <h3 style="margin: 0 0 15px 0;">🔬 Advanced Technical Features</h3>
-                <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 20px; margin-bottom: 20px;">
-                    <div>
-                        <strong>🧠 Enhanced AI:</strong><br>
-                        768-dimensional medical embeddings<br>
-                        Advanced FAISS IVF indexing<br>
-                        Optimized LLM quantization
-                    </div>
-                    <div>
-                        <strong>🛡️ Safety Systems:</strong><br>
-                        Real-time medical validation<br>
-                        Contraindication detection<br>
-                        Gaza-specific risk assessment
-                    </div>
-                    <div>
-                        <strong>⚡ Performance:</strong><br>
-                        Async processing pipeline<br>
-                        Intelligent response caching<br>
-                        Progressive loading indicators
-                    </div>
-                </div>
-                <hr style="border: 1px solid rgba(255,255,255,0.2); margin: 20px 0;">
-                <p style="margin: 0; opacity: 0.8;">
-                    <strong>⚕️ Medical Disclaimer:</strong> This AI assistant provides educational guidance based on established medical protocols. 
-                    It is designed to support, not replace, medical professionals. Always consult qualified healthcare providers for definitive care.
-                </p>
-            </div>
-            """)
-    
-    return interface
-
-def main():
-    """Enhanced main function with comprehensive error handling and system monitoring"""
-    logger.info("🚀 Starting Advanced Gaza First Aid Assistant")
-    
-    try:
-        # System initialization with detailed logging
-        logger.info("🔧 Loading precomputed knowledge base...")
-        system = initialize_enhanced_system()
-        
-        # Verify system components
-        logger.info("✅ Precomputed knowledge base loaded")
-        logger.info("✅ Medical fact checker ready")
-        logger.info("✅ FAISS indexing active")
-        
-        # Create and launch advanced interface
-        logger.info("🎨 Creating advanced Gradio interface...")
-        interface = create_advanced_gradio_interface()
-        
-        logger.info("🌐 Launching advanced interface...")
-        interface.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False,
-            max_threads=6,  # Increased for better async performance
-            show_error=True,
-            quiet=False,
-            favicon_path=None,
-            ssl_verify=False
-        )
-        
-    except Exception as e:
-        logger.error(f"❌ Failed to start Advanced Gaza First Aid Assistant: {e}")
-        print(f"\n🚨 STARTUP ERROR: {e}")
-        print("\n🔧 Troubleshooting Steps:")
-        print("1. Check if all dependencies are installed: pip install -r requirements.txt")
-        print("2. Ensure sufficient memory is available (minimum 4GB RAM recommended)")
-        print("3. Verify data directory exists and contains medical documents")
-        print("4. Check system logs for detailed error information")
-        print("\n📞 For technical support, check the application logs above.")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()
-