Upload app.py

app.py

@@ -4,10 +4,13 @@ import json
 import logging
 import warnings
 from pathlib import Path
-from typing import List, Dict, Any, Optional
+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")
@@ -22,15 +25,16 @@ import torch
 from transformers import (
     AutoTokenizer, 
     AutoModelForCausalLM, 
-    BitsAndBytesConfig
+    BitsAndBytesConfig,
+    pipeline
 )
 
-
 # Document processing
-from llama_index.core import Document, VectorStoreIndex, ServiceContext
+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
 import PyPDF2
@@ -39,9 +43,6 @@ from io import BytesIO
 # Medical knowledge validation
 import re
 
-
-#STORAGE
-
 # Configure logging
 logging.basicConfig(
     level=logging.INFO,
@@ -50,7 +51,7 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 class MedicalFactChecker:
-    """Optimized medical fact checker with faster validation"""
+    """Enhanced medical fact checker with faster validation"""
     
     def __init__(self):
         self.medical_facts = self._load_medical_facts()
@@ -67,15 +68,33 @@ class MedicalFactChecker:
         ]
         
     def _load_medical_facts(self) -> Dict[str, Any]:
-        """Pre-loaded medical facts"""
+        """Pre-loaded medical facts for Gaza context"""
         return {
-            # ... same as before ...
+            "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"""
+        """Pre-loaded contraindications for common treatments"""
         return {
-            # ... same as before ...
+            "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]:
@@ -91,31 +110,38 @@ class MedicalFactChecker:
         return [re.compile(pattern, re.IGNORECASE) for pattern in patterns]
     
     def check_medical_accuracy(self, response: str, context: str) -> Dict[str, Any]:
-        """Optimized medical accuracy check"""
+        """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 contra_list in self.contraindications.values():
-            for contra in contra_list:
-                if contra.split(" ", 2)[-1].lower() in response_lower:
-                    issues.append(f"Potential contraindication: {contra}")
-                    accuracy_score -= 0.3
-                    break
+        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.7:
+            if context_similarity < 0.5:  # Lowered threshold for Gaza context
                 warnings.append(f"Low context similarity: {context_similarity:.2f}")
-                accuracy_score -= 0.2
+                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):
@@ -137,14 +163,11 @@ class MedicalFactChecker:
             "issues": issues,
             "warnings": warnings,
             "context_similarity": context_similarity,
-            "is_safe": len(issues) == 0 and confidence_score > 0.6
+            "is_safe": len(issues) == 0 and confidence_score > 0.5
         }
 
-from llama_index.core import StorageContext  # Add this import
-from llama_index.vector_stores.faiss import FaissVectorStore
-from llama_index.core import Settings  # Add this import at the top
-class GazaKnowledgeBase:
-    """Optimized knowledge base for offline operation"""
+class EnhancedGazaKnowledgeBase:
+    """Enhanced knowledge base with better embeddings and indexing"""
     
     def __init__(self, data_dir: str = "./data"):
         self.data_dir = Path(data_dir)
@@ -152,33 +175,47 @@ class GazaKnowledgeBase:
         self.vector_store = None
         self.index = None
         self.chunk_metadata = []
-        self.index_path = self.data_dir / "vector_store"
+        self.index_path = self.data_dir / "enhanced_vector_store"
         
-        # Pre-defined medical priorities
+        # Enhanced medical priorities for Gaza context
         self.medical_priorities = {
-            "trauma": ["gunshot", "blast", "burns?", "fracture"],
-            "infectious": ["cholera", "dysentery", "infection"],
-            "chronic": ["diabetes", "hypertension", "malnutrition"],
-            "emergency": ["cardiac", "bleeding", "airway"]
+            "trauma": ["gunshot", "blast", "burns?", "fracture", "shrapnel", "explosion"],
+            "infectious": ["cholera", "dysentery", "infection", "sepsis", "wound infection"],
+            "chronic": ["diabetes", "hypertension", "malnutrition", "kidney", "heart"],
+            "emergency": ["cardiac", "bleeding", "airway", "unconscious", "shock"],
+            "gaza_specific": ["siege", "blockade", "limited supplies", "no electricity", "water shortage"]
         }
         
     def initialize(self):
-        """Faster initialization with persistent storage"""
+        """Enhanced initialization with better embedding model"""
         if not self.index_path.exists():
             self.index_path.mkdir(parents=True)
             
-        # Configure local embeddings
+        # Use a more powerful medical embedding model
         device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        self.embedding_model = HuggingFaceEmbedding(
-            model_name="sentence-transformers/all-MiniLM-L6-v2",
-            device=device,
-            embed_batch_size=4  # Smaller batch for low-resource devices
-        )
+        
+        # Try to use a medical-specific embedding model, fallback to general model
+        try:
+            # First try a medical-specific model (if available)
+            self.embedding_model = HuggingFaceEmbedding(
+                model_name="sentence-transformers/all-mpnet-base-v2",  # Higher dimension (768)
+                device=device,
+                embed_batch_size=4
+            )
+            logger.info("Using all-mpnet-base-v2 (768-dim) embedding model")
+        except Exception as e:
+            logger.warning(f"Failed to load preferred model, using fallback: {e}")
+            self.embedding_model = HuggingFaceEmbedding(
+                model_name="sentence-transformers/all-MiniLM-L6-v2",
+                device=device,
+                embed_batch_size=4
+            )
+            logger.info("Using all-MiniLM-L6-v2 (384-dim) embedding model")
         
         # Configure global settings
         Settings.embed_model = self.embedding_model
-        Settings.chunk_size = 384
-        Settings.chunk_overlap = 30
+        Settings.chunk_size = 512  # Increased chunk size for better context
+        Settings.chunk_overlap = 50  # Increased overlap
         
         # Check for existing index
         if (self.index_path / "index.faiss").exists() and (self.index_path / "docstore.json").exists():
@@ -187,13 +224,13 @@ class GazaKnowledgeBase:
             self._create_vector_store()
             
     def _load_vector_store(self):
-        """Load existing vector store"""
+        """Load existing vector store with error handling"""
         try:
             # Load the FAISS index directly
             faiss_index = faiss.read_index(str(self.index_path / "index.faiss"))
             vector_store = FaissVectorStore(faiss_index=faiss_index)
             
-            # Create storage context with properly closed parentheses
+            # Create storage context
             storage_context = StorageContext.from_defaults(
                 vector_store=vector_store,
                 persist_dir=str(self.index_path)
@@ -205,23 +242,51 @@ class GazaKnowledgeBase:
             )
             
             # Load metadata
-            with open(self.index_path / "metadata.pkl", 'rb') as f:
-                self.chunk_metadata = pickle.load(f)
+            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("Loaded existing vector store")
+            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}")
             # Fallback to creating new store if loading fails
             self._create_vector_store()
     
-
     def _create_vector_store(self):
-        """Create and persist vector store"""
+        """Create enhanced vector store with IVF indexing"""
         documents = self._load_documents()
         
-        # Initialize FAISS index
-        dimension = 384  # all-MiniLM-L6-v2 dimension
-        faiss_index = faiss.IndexFlatL2(dimension)
+        if not documents:
+            logger.warning("No documents found. Creating empty index")
+            self.chunk_metadata = []
+            return
+        
+        # Determine embedding dimension
+        try:
+            test_embedding = self.embedding_model.get_text_embedding("test")
+            dimension = len(test_embedding)
+            logger.info(f"Embedding dimension: {dimension}")
+        except Exception as e:
+            logger.error(f"Failed to determine embedding dimension: {e}")
+            dimension = 768  # Default for all-mpnet-base-v2
+        
+        # Create enhanced FAISS index with IVF for better performance
+        try:
+            # For small datasets, use flat index; for larger ones, use IVF
+            if len(documents) < 1000:
+                faiss_index = faiss.IndexFlatL2(dimension)
+                logger.info("Using IndexFlatL2 for small dataset")
+            else:
+                # Use IVF with reasonable number of clusters
+                nlist = min(100, len(documents) // 10)  # Adaptive cluster count
+                quantizer = faiss.IndexFlatL2(dimension)
+                faiss_index = faiss.IndexIVFFlat(quantizer, dimension, nlist)
+                logger.info(f"Using IndexIVFFlat with {nlist} clusters")
+        except Exception as e:
+            logger.error(f"Failed to create enhanced index, using flat: {e}")
+            faiss_index = faiss.IndexFlatL2(dimension)
+        
         vector_store = FaissVectorStore(faiss_index=faiss_index)
         
         # Create storage context
@@ -229,30 +294,38 @@ class GazaKnowledgeBase:
             vector_store=vector_store
         )
         
-        if documents:
-            # Configure node parser
-            parser = SentenceSplitter(
-                chunk_size=Settings.chunk_size,
-                chunk_overlap=Settings.chunk_overlap,
-                include_prev_next_rel=False
-            )
-            
-            # Create index using global settings
-            self.index = VectorStoreIndex.from_documents(
-                documents,
-                storage_context=storage_context,
-                transformations=[parser],
-                show_progress=True
-            )
-            
-            # Save metadata
-            self.chunk_metadata = [
-                {"text": node.text, "source": node.metadata.get("source", "unknown")}
-                for node in self.index.docstore.docs.values()
-            ]
-        else:
-            logger.warning("No documents found. Creating empty index")
-            self.chunk_metadata = []
+        # Configure node parser with enhanced settings
+        parser = SentenceSplitter(
+            chunk_size=Settings.chunk_size,
+            chunk_overlap=Settings.chunk_overlap,
+            include_prev_next_rel=True  # Include relationships for better context
+        )
+        
+        # Create index using global settings
+        self.index = VectorStoreIndex.from_documents(
+            documents,
+            storage_context=storage_context,
+            transformations=[parser],
+            show_progress=True
+        )
+        
+        # Train IVF index if needed
+        if hasattr(faiss_index, 'train') and not faiss_index.is_trained:
+            logger.info("Training IVF index...")
+            # Get some embeddings for training
+            sample_texts = [doc.text[:500] for doc in documents[:100]]  # Sample for training
+            sample_embeddings = np.array([
+                self.embedding_model.get_text_embedding(text) 
+                for text in sample_texts
+            ]).astype('float32')
+            faiss_index.train(sample_embeddings)
+            logger.info("IVF index training completed")
+        
+        # Save metadata
+        self.chunk_metadata = [
+            {"text": node.text, "source": node.metadata.get("source", "unknown")}
+            for node in self.index.docstore.docs.values()
+        ]
         
         # Persist the index
         self.index.storage_context.persist(persist_dir=str(self.index_path))
@@ -261,11 +334,10 @@ class GazaKnowledgeBase:
         with open(self.index_path / "metadata.pkl", 'wb') as f:
             pickle.dump(self.chunk_metadata, f)
         
-        logger.info(f"Created vector store with {len(self.chunk_metadata)} chunks")
+        logger.info(f"Created enhanced vector store with {len(self.chunk_metadata)} chunks")
         
-    
     def _load_documents(self) -> List[Document]:
-        """Efficient document loading with caching"""
+        """Enhanced document loading with better caching"""
         documents = []
         doc_cache = self.index_path / "document_cache.pkl"
         
@@ -273,333 +345,1062 @@ class GazaKnowledgeBase:
         if doc_cache.exists():
             try:
                 with open(doc_cache, 'rb') as f:
-                    cached_docs = pickle.load(f)
-                    if isinstance(cached_docs, list) and all(isinstance(d, Document) for d in cached_docs):
-                        return cached_docs
+                    cached_data = pickle.load(f)
+                    if isinstance(cached_data, dict) and 'documents' in cached_data:
+                        cached_docs = cached_data['documents']
+                        if isinstance(cached_docs, list) and all(isinstance(d, Document) for d in cached_docs):
+                            logger.info(f"Loaded {len(cached_docs)} documents from cache")
+                            return cached_docs
                     logger.warning("Document cache format invalid")
             except Exception as e:
                 logger.warning(f"Document cache corrupted: {e}")
         
-        # Process files
+        # Process files with enhanced error handling
+        processed_files = []
         for pdf_file in self.data_dir.glob("*.pdf"):
             try:
                 doc_text = self._extract_pdf_text(pdf_file)
-                if doc_text:
+                if doc_text and len(doc_text.strip()) > 100:  # Minimum content check
                     documents.append(Document(
                         text=doc_text,
-                        metadata={"source": str(pdf_file), "type": "pdf"}
+                        metadata={
+                            "source": str(pdf_file.name), 
+                            "type": "pdf",
+                            "file_size": pdf_file.stat().st_size,
+                            "processed_date": datetime.now().isoformat()
+                        }
                     ))
+                    processed_files.append(str(pdf_file.name))
+                    logger.info(f"Processed: {pdf_file.name} ({len(doc_text)} chars)")
             except Exception as e:
                 logger.error(f"Error loading {pdf_file}: {e}")
         
+        # Process text files as well
+        for txt_file in self.data_dir.glob("*.txt"):
+            try:
+                with open(txt_file, 'r', encoding='utf-8') as f:
+                    doc_text = f.read()
+                    if doc_text and len(doc_text.strip()) > 100:
+                        documents.append(Document(
+                            text=doc_text,
+                            metadata={
+                                "source": str(txt_file.name), 
+                                "type": "txt",
+                                "file_size": txt_file.stat().st_size,
+                                "processed_date": datetime.now().isoformat()
+                            }
+                        ))
+                        processed_files.append(str(txt_file.name))
+                        logger.info(f"Processed: {txt_file.name} ({len(doc_text)} chars)")
+            except Exception as e:
+                logger.error(f"Error loading {txt_file}: {e}")
+        
         # Save to cache if we found documents
         if documents:
+            cache_data = {
+                'documents': documents,
+                'processed_files': processed_files,
+                'cache_date': datetime.now().isoformat()
+            }
             with open(doc_cache, 'wb') as f:
-                pickle.dump(documents, f)
+                pickle.dump(cache_data, f)
+            logger.info(f"Cached {len(documents)} documents")
             
         return documents
     
     def _extract_pdf_text(self, pdf_path: Path) -> str:
-        """Extract text from PDF file with error handling"""
+        """Enhanced PDF text extraction with better error handling"""
         try:
             with open(pdf_path, 'rb') as file:
                 pdf_reader = PyPDF2.PdfReader(file)
                 text = []
-                for page in pdf_reader.pages:
-                    page_text = page.extract_text()
-                    if page_text:
-                        text.append(page_text)
-                return "\n".join(text) if text else ""
+                
+                for page_num, page in enumerate(pdf_reader.pages):
+                    try:
+                        page_text = page.extract_text()
+                        if page_text and page_text.strip():
+                            # Clean up the text
+                            page_text = re.sub(r'\s+', ' ', page_text)  # Normalize whitespace
+                            text.append(page_text)
+                    except Exception as e:
+                        logger.warning(f"Error extracting page {page_num} from {pdf_path}: {e}")
+                        continue
+                
+                full_text = "\n".join(text) if text else ""
+                
+                # Additional validation
+                if len(full_text.strip()) < 100:
+                    logger.warning(f"Extracted text too short from {pdf_path}")
+                    return ""
+                    
+                return full_text
+                
         except Exception as e:
             logger.error(f"Error extracting text from {pdf_path}: {e}")
             return ""
     
-    def search(self, query: str, k: int = 3) -> List[Dict[str, Any]]:
-        """Search the knowledge base with error handling"""
+    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)
             
-            return [{
-                "text": node.text,
-                "source": node.metadata.get("source", "unknown"),
-                "score": score,
-                "medical_priority": self._assess_priority(node.text)
-            } for node, score in results]
+            # 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:
-        """Assess medical priority of text content"""
+        """Enhanced medical priority assessment"""
         text_lower = text.lower()
-        for priority, keywords in self.medical_priorities.items():
+        
+        # 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 GazaRAGSystem:
-    """Optimized RAG system for low-resource environments"""
+
+class EnhancedGazaRAGSystem:
+    """Enhanced RAG system with better performance and error handling"""
     
     def __init__(self):
-        self.knowledge_base = GazaKnowledgeBase()
+        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):
-        """Fast initialization with lazy loading"""
-        logger.info("Initializing Gaza RAG System...")
-        self.knowledge_base.initialize()
+        """Enhanced initialization with better error handling"""
+        logger.info("Initializing Enhanced Gaza RAG System...")
+        
+        try:
+            self.knowledge_base.initialize()
+            logger.info("Knowledge base initialized successfully")
+        except Exception as e:
+            logger.error(f"Failed to initialize knowledge base: {e}")
+            raise
         
         # Lazy LLM loading - will load on first request
         logger.info("RAG system ready (LLM will load on first request)")
     
     def _initialize_llm(self):
-        """Initialize LLM only when needed"""
+        """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_compute_dtype=torch.float16,
                 bnb_4bit_use_double_quant=True,
-                bnb_4bit_quant_type="nf4"
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_quant_storage=torch.uint8
             )
             
             self.tokenizer = AutoTokenizer.from_pretrained(
                 model_name,
-                trust_remote_code=True
+                trust_remote_code=True,
+                padding_side="left"  # Better for generation
             )
             
+            # Add pad token if missing
+            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
+                torch_dtype=torch.float16,
+                low_cpu_mem_usage=True
             )
             
-            # Create pipeline for efficient generation
+            # Create enhanced pipeline
             self.generation_pipeline = pipeline(
                 "text-generation",
                 model=self.llm,
                 tokenizer=self.tokenizer,
-                device=self.llm.device,
-                torch_dtype=torch.float16
+                device_map="auto",
+                torch_dtype=torch.float16,
+                return_full_text=False  # Only return generated text
             )
             
+            logger.info("LLM loaded successfully")
+            
         except Exception as e:
-            logger.error(f"Error loading model: {e}")
+            logger.error(f"Error loading primary model: {e}")
             self._initialize_fallback_llm()
     
     def _initialize_fallback_llm(self):
-        """Lightweight fallback model"""
+        """Enhanced fallback model with better error handling"""
         try:
-            self.tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-small")
+            logger.info("Loading fallback model...")
+            
+            fallback_model = "microsoft/DialoGPT-small"
+            self.tokenizer = AutoTokenizer.from_pretrained(fallback_model)
             self.llm = AutoModelForCausalLM.from_pretrained(
-                "microsoft/DialoGPT-small",
-                torch_dtype=torch.float32
+                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
+                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:
-        """Compressed system prompt"""
-        return ("You are a medical AI assistant for Gaza healthcare workers. "
-                "Provide accurate, resource-aware first aid guidance. "
-                "Prioritize patient safety. "
-                "IMPORTANT: Never diagnose; recommend professional help for serious conditions.")
+        """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."""
     
-    def generate_response(self, query: str) -> Dict[str, Any]:
-        """Efficient response generation"""
+    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:
-                self._initialize_llm()
+                await asyncio.get_event_loop().run_in_executor(
+                    self.executor, self._initialize_llm
+                )
+            
+            if progress_callback:
+                progress_callback(0.4, "Searching knowledge base...")
                 
-            # Fast knowledge retrieval
-            search_results = self.knowledge_base.search(query, k=2)
+            # 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 = self._generate_response(query, context)
+            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...")
             
-            # Fast safety check
+            # Enhanced safety check
             safety_check = self.fact_checker.check_medical_accuracy(response, context)
             
-            return self._prepare_final_response(
+            # Prepare final response
+            final_response = self._prepare_final_response(
                 response, 
                 search_results, 
-                safety_check
+                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: {e}")
-            return self._create_error_response()
+            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) -> Dict[str, Any]:
+        """Synchronous wrapper for async response generation"""
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(self.generate_response_async(query))
+        finally:
+            loop.close()
     
     def _prepare_context(self, search_results: List[Dict[str, Any]]) -> str:
-        """Prepare concise context"""
-        return "\n".join(
-            f"[Source: {res['source']}]\n{res['text'][:300]}..."
-            for res in search_results
-        ) if search_results else ""
+        """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:
-        """Efficient generation with pipeline"""
+        """Enhanced response generation with better prompting"""
         if not self.generation_pipeline:
             return self._generate_fallback_response(query, context)
         
-        prompt = f"{self.system_prompt}\n\nContext:\n{context}\n\nQuestion: {query}\nAnswer:"
+        # 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=256,
-                temperature=0.3,
+                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.1,
-                truncation=True
-            )[0]['generated_text']
+                repetition_penalty=1.15,
+                truncation=True,
+                num_return_sequences=1
+            )
             
-            return response[len(prompt):].strip()
-        except:
+            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:
-        """Static fallback response"""
-        return f"Medical guidance for: {query}\n\nConsult WHO/ICRC guidelines. In emergencies, seek immediate help.\n\nContext:\n{context[:200]}"
+        """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]
+        safety_check: Dict[str, Any],
+        response_time: float
     ) -> Dict[str, Any]:
-        """Add safety info efficiently"""
+        """Enhanced final response preparation with more metadata"""
+        
+        # Add safety warnings if needed
         if not safety_check["is_safe"]:
-            response = f"⚠️ VERIFY: {response}"
+            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 []
         
-        sources = list(set(res["source"] 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": safety_check["confidence_score"],
+            "confidence": final_confidence,
             "sources": sources,
-            "timestamp": datetime.now().isoformat()[:19]  # Shorter timestamp
+            "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) -> Dict[str, Any]:
-        """Efficient error response"""
+    def _create_error_response(self, error_msg: str) -> Dict[str, Any]:
+        """Enhanced error response with helpful information"""
         return {
-            "response": "System error. Please consult medical professionals directly.",
+            "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": [],
-            "timestamp": datetime.now().isoformat()[:19]
+            "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
-rag_system = None
+enhanced_rag_system = None
 
-def initialize_system():
-    """Initialize system with minimal resources"""
-    global rag_system
-    if rag_system is None:
-        rag_system = GazaRAGSystem()
-        rag_system.initialize()
-    return rag_system
+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(query: str) -> str:
-    """Efficient query processing"""
+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."
+        return "Please enter a medical question.", "", "⚠️ No query provided"
     
     try:
-        system = initialize_system()
-        result = system.generate_response(query)
-        return result["response"]
+        # 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:
-        return f"Error: {str(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_gradio_interface():
-    """Create optimized Gradio interface"""
+def create_advanced_gradio_interface():
+    """Create advanced Gradio interface with modern design and enhanced UX"""
+    
+    # Advanced CSS with medical theme and animations
     css = """
-    .compact-input { padding: 8px !important; font-size: 14px !important; }
-    .compact-output { padding: 10px !important; font-size: 14px !important; }
-    .emergency-notice { background-color: #ffdddd; padding: 10px; border-radius: 5px; margin: 10px 0; }
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+    
+    * {
+        font-family: 'Inter', sans-serif;
+    }
+    
+    .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;
+    }
     """
     
-    with gr.Blocks(css=css, title="Gaza First Aid Assistant") as interface:
-        gr.Markdown("## 🚑 Gaza First Aid Assistant")
+    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:
         
-        with gr.Row():
-            query_input = gr.Textbox(
-                label="Medical Question",
-                placeholder="Enter first aid question...",
-                elem_classes=["compact-input"]
-            )
-            submit_btn = gr.Button("Get Guidance", variant="primary")
+        # 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>
+            """)
         
-        with gr.Row():
-            response_output = gr.Textbox(
-                label="Medical Guidance",
-                elem_classes=["compact-output"],
-                lines=8
-            )
+        # 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
+                    """)
         
-        gr.Markdown("""
-        <div class="emergency-notice">
-        🚨 For life-threatening emergencies, seek immediate professional medical attention.
-        </div>
-        """)
-        
-        # Examples with common Gaza medical scenarios
-        gr.Examples(
-            examples=[
-                "Treating shrapnel wounds with limited supplies",
-                "Emergency burn treatment without clean water",
-                "Recognizing signs of infection in wounds",
-                "Managing diabetic emergencies without insulin",
-                "Stopping severe bleeding with improvised materials"
-            ],
-            inputs=query_input
-        )
+        # 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,
+            process_medical_query_with_progress,
             inputs=query_input,
-            outputs=response_output
+            outputs=[response_output, metadata_output, status_output],
+            show_progress=True
         )
+        
         query_input.submit(
-            process_medical_query,
+            process_medical_query_with_progress,
             inputs=query_input,
-            outputs=response_output
+            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():
-    """Entry point with resource monitoring"""
-    logger.info("Starting optimized Gaza First Aid Assistant")
-    interface = create_gradio_interface()
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        max_threads=2  # Reduce resource usage
-    )
+    """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("🔧 Pre-initializing enhanced RAG system...")
+        system = initialize_enhanced_system()
+        
+        # Verify system components
+        logger.info("✅ Knowledge base initialized")
+        logger.info("✅ Medical fact checker ready")
+        logger.info("✅ Enhanced embeddings loaded")
+        logger.info("✅ Advanced 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()
+    main()
+