Upload 14 files

.dockerignore

@@ -0,0 +1,24 @@
+.git
+.gitignore
+*.log
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env
+pip-log.txt
+.tox
+.coverage
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+.DS_Store
+rag_system.log
+test_openrouter_api.py
+DataSet/
+*.tmp
+temp/

Agent.py

@@ -0,0 +1,1189 @@
+import os
+import json
+import requests
+import time
+import pickle
+import hashlib
+import random
+import re
+from typing import List, Optional, Any
+import logging
+from dotenv import load_dotenv
+from datetime import datetime
+
+# === LANGUAGE DETECTION IMPORTS ===
+from langdetect import detect, DetectorFactory
+DetectorFactory.seed = 0
+# ==================================
+
+# === OPENAI CLIENT IMPORT ===
+from openai import OpenAI
+# ============================
+
+# === HUGGING FACE DETECTION ===
+IS_HUGGING_FACE = os.path.exists('/.dockerenv') or 'SPACE_ID' in os.environ
+
+if IS_HUGGING_FACE:
+    print("🚀 Hugging Face Space detected")
+    os.environ['FORCE_FREE_MODEL'] = 'true'
+
+# Load environment variables
+if not IS_HUGGING_FACE:
+    env_path = os.path.join("config", ".env")
+    print(f"🔍 Looking for .env file at: {env_path}")
+    if os.path.exists(env_path):
+        load_dotenv(env_path)
+        print("✅ .env file loaded successfully")
+    else:
+        print(f"❌ .env file not found at: {env_path}")
+else:
+    print("✅ Hugging Face environment - using repository secrets")
+
+# === CACHE CONFIGURATION ===
+CACHE_DIR = "cache"
+RESPONSE_CACHE_FILE = os.path.join(CACHE_DIR, "response_cache.pkl")
+
+class ResponseCache:
+    """Simple response cache to avoid repeated LLM calls"""
+    
+    def __init__(self):
+        self.cache = {}
+        self.load_cache()
+    
+    def get_cache_key(self, query: str, context_chunks: List[Any]) -> str:
+        """Generate unique cache key from query and context"""
+        query_hash = hashlib.md5(query.encode()).hexdigest()
+        if context_chunks:
+            context_text = "".join([chunk.text[:100] for chunk in context_chunks if hasattr(chunk, 'text')])
+            context_hash = hashlib.md5(context_text.encode()).hexdigest()
+        else:
+            context_hash = "no_context"
+        return f"{query_hash}_{context_hash}"
+    
+    def get(self, key: str) -> Optional[str]:
+        """Get cached response if exists and not expired"""
+        if key in self.cache:
+            cached_time, response = self.cache[key]
+            if time.time() - cached_time < 24 * 3600:
+                return response
+            else:
+                del self.cache[key]
+        return None
+    
+    def set(self, key: str, response: str):
+        """Cache response with timestamp"""
+        self.cache[key] = (time.time(), response)
+        self.save_cache()
+    
+    def save_cache(self):
+        """Save cache to disk"""
+        os.makedirs(CACHE_DIR, exist_ok=True)
+        with open(RESPONSE_CACHE_FILE, 'wb') as f:
+            pickle.dump(self.cache, f)
+    
+    def load_cache(self):
+        """Load cache from disk"""
+        try:
+            if os.path.exists(RESPONSE_CACHE_FILE):
+                with open(RESPONSE_CACHE_FILE, 'rb') as f:
+                    self.cache = pickle.load(f)
+                print(f"✅ Loaded response cache with {len(self.cache)} entries")
+        except Exception as e:
+            print(f"⚠️ Could not load cache: {e}")
+            self.cache = {}
+
+# Initialize cache globally
+response_cache = ResponseCache()
+
+# === Conversation Logger ===
+class ConversationLogger:
+    """JSON-based conversation logging system"""
+    
+    def __init__(self, log_file="conversations.json"):
+        self.log_file = log_file
+        self.ensure_log_file()
+    
+    def ensure_log_file(self):
+        """Ensure log file exists with proper structure"""
+        if not os.path.exists(self.log_file):
+            with open(self.log_file, 'w', encoding='utf-8') as f:
+                json.dump([], f, indent=2)
+    
+    def log_conversation(self, user_input: str, llm_response: str, language: str, response_type: str):
+        """Log conversation to JSON file"""
+        try:
+            # Read existing data
+            with open(self.log_file, 'r', encoding='utf-8') as f:
+                conversations = json.load(f)
+            
+            # Add new conversation
+            conversation_entry = {
+                "user_input": user_input,
+                "llm_response": llm_response,
+                "language": language,
+                "response_type": response_type
+            }
+            
+            conversations.append(conversation_entry)
+            
+            # Write back to file
+            with open(self.log_file, 'w', encoding='utf-8') as f:
+                json.dump(conversations, f, indent=2, ensure_ascii=False)
+                
+            print(f"💾 Conversation logged to {self.log_file}")
+            
+        except Exception as e:
+            print(f"❌ Error logging conversation: {e}")
+
+# Initialize global logger
+conversation_logger = ConversationLogger()
+
+# === Centralized Configuration System ===
+class Config:
+    """Centralized configuration - loads from config.json and .env"""
+    
+    def __init__(self):
+        self.api_keys = []
+        self.current_key_index = 0
+        self.settings = self._load_config_file()
+        self._correct_dataset_path()
+        
+        if IS_HUGGING_FACE:
+            self._apply_hugging_face_optimizations()
+        
+        self.SUPPORTED_LANGUAGES = ["english", "urdu"]
+        self.DEFAULT_LANGUAGE = "english"
+        
+        # Apply settings
+        self.MODEL_PROVIDER = self.settings["model_provider"]
+        self.MODEL_ID = self.settings["model_id"]
+        self.API_KEYS_FOLDER = self.settings["api_keys_folder"]
+        self.INDEX_PATH = self.settings["index_path"]
+        self.DATASET_PATH = self.settings["dataset_path"]
+        self.SIMILARITY_TOP_K = self.settings["similarity_top_k"]
+        self.TEMPERATURE = self.settings["temperature"]
+        self.MAX_TOKENS = self.settings["max_tokens"]
+        self.FALLBACK_MESSAGE = self.settings["fallback_message"]
+        
+        self.api_keys = self._load_api_keys()
+        self.api_key = self._get_current_api_key()
+        
+        self._validate_config()
+    
+    def _correct_dataset_path(self):
+        """Automatically find the correct dataset path"""
+        original_path = self.settings["dataset_path"]
+        possible_paths = [
+            original_path,
+            f"DataSet/{original_path}",
+            f"data/{original_path}",
+            "DataSet/breast_cancer.json",
+            "breast_cancer.json"
+        ]
+        
+        for path in possible_paths:
+            if os.path.exists(path):
+                if path != original_path:
+                    print(f"🔄 Using dataset at: {path}")
+                    self.settings["dataset_path"] = path
+                else:
+                    print(f"✅ Dataset found at: {path}")
+                return
+        
+        print(f"❌ Dataset not found in any location")
+    
+    def _apply_hugging_face_optimizations(self):
+        """Apply optimizations for Hugging Face deployment"""
+        print("🔧 Applying Hugging Face optimizations...")
+        self.settings["max_tokens"] = 300
+        self.settings["similarity_top_k"] = 3
+        self.settings["model_id"] = "meta-llama/llama-3.3-70b-instruct:free"
+    
+    def _load_config_file(self):
+        """Load configuration from config/config.json file"""
+        config_file = os.path.join("config", "config.json")
+        default_config = {
+            "model_provider": "openrouter",
+            "model_id": "deepseek/deepseek-r1:free",
+            "api_keys_folder": "config",
+            "index_path": "cancer_index_store",
+            "dataset_path": "breast_cancer.json",
+            "similarity_top_k": 5,
+            "temperature": 0.2,
+            "max_tokens": 350,
+            "fallback_message": "Sorry, I don't know the answer."
+        }
+    
+        try:
+            if os.path.exists(config_file):
+                with open(config_file, 'r', encoding='utf-8') as f:
+                    loaded_config = json.load(f)
+                merged_config = {**default_config, **loaded_config}
+                
+                if IS_HUGGING_FACE:
+                    merged_config["model_id"] = "meta-llama/llama-3.3-70b-instruct:free"
+                    merged_config["max_tokens"] = 300
+                
+                return merged_config
+            else:
+                os.makedirs(os.path.dirname(config_file), exist_ok=True)
+                with open(config_file, 'w', encoding='utf-8') as f:
+                    json.dump(default_config, f, indent=4)
+                print("📁 Created default config file")
+                return default_config
+        except Exception as e:
+            print(f"❌ Error loading config: {e}")
+            return default_config
+
+    def _load_api_keys(self) -> List[str]:
+        """Load API keys from environment variables"""
+        api_keys = []
+        print("🔍 Checking for API keys in environment variables...")
+        
+        keys_to_check = ["API_KEY", "API_KEY_2", "API_KEY_3", "API_KEY_4", "API_KEY_5"]
+        
+        for key_name in keys_to_check:
+            key_value = os.getenv(key_name)
+            if key_value and key_value.strip():
+                api_keys.append(key_value.strip())
+                print(f"✅ Found {key_name}")
+        
+        return api_keys
+    
+    def _get_current_api_key(self) -> str:
+        """Get current active API key"""
+        if self.api_keys and self.current_key_index < len(self.api_keys):
+            return self.api_keys[self.current_key_index]
+        return ""
+    
+    def rotate_to_next_key(self) -> bool:
+        """Rotate to next API key if available"""
+        if self.current_key_index < len(self.api_keys) - 1:
+            self.current_key_index += 1
+            self.api_key = self._get_current_api_key()
+            print(f"🔄 Rotated to API key {self.current_key_index + 1}")
+            return True
+        else:
+            print("❌ No more API keys available")
+            return False
+    
+    def _validate_config(self):
+        """Validate configuration"""
+        if not self.api_keys:
+            print("❌ No API keys found in environment variables")
+            if IS_HUGGING_FACE:
+                print("💡 Please add API keys in Hugging Face Space Settings → Repository secrets")
+        else:
+            print(f"✅ Found {len(self.api_keys)} API key(s)")
+
+# Initialize configuration
+config = Config()
+
+# === Setup Logging ===
+if IS_HUGGING_FACE:
+    logging.basicConfig(
+        level=logging.INFO, 
+        format='%(asctime)s - %(levelname)s - %(message)s',
+        handlers=[logging.StreamHandler()]
+    )
+else:
+    logging.basicConfig(
+        level=logging.INFO, 
+        format='%(asctime)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.StreamHandler(),
+            logging.FileHandler('rag_system.log')
+        ]
+    )
+
+# === FAST INDEX LOADING ===
+def load_index_fast():
+    """Fast index loading by reusing cached embeddings"""
+    try:
+        from llama_index.core import StorageContext, VectorStoreIndex
+        from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+        
+        print(f"🔍 Loading index from: {config.INDEX_PATH}")
+        if not os.path.exists(config.INDEX_PATH):
+            print(f"❌ Index path doesn't exist: {config.INDEX_PATH}")
+            return None, None
+        
+        embed_model = HuggingFaceEmbedding(model_name="sentence-transformers/all-MiniLM-L6-v2")
+        storage_context = StorageContext.from_defaults(persist_dir=config.INDEX_PATH)
+        index = VectorStoreIndex.from_documents(
+            [], 
+            storage_context=storage_context, 
+            embed_model=embed_model
+        )
+        retriever = index.as_retriever(similarity_top_k=config.SIMILARITY_TOP_K)
+        print("✅ Index loaded successfully")
+        return index, retriever
+        
+    except Exception as e:
+        print(f"❌ Failed to load index: {e}")
+        import traceback
+        traceback.print_exc()
+        return None, None
+
+def load_index():
+    return load_index_fast()
+
+# === Enhanced RAG System Class ===
+class BreastCancerRAGSystem:
+    """Enhanced RAG system for breast cancer information with emotional support"""
+    
+    def __init__(self, index, retriever):
+        self.index = index
+        self.retriever = retriever
+        self.conversation_history = []
+        
+        if not config.api_keys:
+            logging.error("🚫 System initialized without API key - LLM features will not work")
+
+    def get_predefined_questions(self, language: str = "english") -> List[dict]:
+        """Get predefined daily routine questions for breast cancer patients"""
+        
+        english_questions = [
+            {
+                "question": "What are some gentle exercises I can do during recovery?",
+                "category": "exercise", 
+                "icon": "fas fa-walking"
+            },
+            {
+                "question": "How do I deal with anxiety about my next treatment?",
+                "category": "emotional",
+                "icon": "fas fa-heart"
+            },
+            {
+                "question": "When can I expect my hair to grow back after treatment?",
+                "category": "appearance",
+                "icon": "fas fa-user"
+            },
+            {
+                "question": "How do I talk to my family about my diagnosis?",
+                "category": "emotional",
+                "icon": "fas fa-users"
+            },
+            {
+                "question": "What are the signs of infection I should watch for?",
+                "category": "symptoms",
+                "icon": "fas fa-exclamation-triangle"
+            }
+        ]
+        
+        urdu_questions = [
+            {
+                "question": "کیموتھراپی کے دوران تھکاوٹ کیسے کم کریں؟",
+                "category": "symptoms",
+                "icon": "fas fa-bed"
+            },
+            {
+                "question": "ریکوری کے دوران ہلکی پھلکی ورزشیں کون سی ہیں؟",
+                "category": "exercise",
+                "icon": "fas fa-walking"
+            },
+            {
+                "question": "اگلے علاج کے بارے میں پریشانی کیسے دور کریں؟",
+                "category": "emotional",
+                "icon": "fas fa-heart"
+            },
+            {
+                "question": "کیموتھراپی کے بعد متلی کے لیے کون سی غذائیں مفید ہیں؟",
+                "category": "nutrition", 
+                "icon": "fas fa-apple-alt"
+            },
+            {
+                "question": "ماسٹکٹومی کے بعد درد کیسے منظم کریں؟",
+                "category": "pain",
+                "icon": "fas fa-hand-holding-heart"
+            },
+        ]
+        
+        return urdu_questions if language == "urdu" else english_questions
+    
+    def detect_language(self, text: str) -> str:
+        """Detect language of user query"""
+        try:
+            urdu_pattern = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]+')
+            if urdu_pattern.search(text):
+                return 'urdu'
+            detected_lang = detect(text)
+            return 'urdu' if detected_lang == 'ur' else 'english'
+        except:
+            return 'english'
+
+    def _clean_urdu_text(self, text: str) -> str:
+        """Advanced cleaning for Urdu text with comprehensive spelling correction"""
+        if not text or not text.strip():
+            return text
+            
+        # Comprehensive spelling correction dictionary
+        spelling_corrections = {
+            # Character repetition fixes
+            'مجہے': 'مجھے',
+            'پروگرہوں': 'پروگرام',
+            'کہےنسر': 'کینسر',
+            'ڈڈاکٹر': 'ڈاکٹر',
+            'ہےہ': 'ہے',
+            'مہےں': 'میں',
+            'ہےں': 'ہیں',
+            'ھے': 'ہے',
+            'ھوں': 'ہوں',
+            'ھیں': 'ہیں',
+            'ےے': 'ے',
+            'ںں': 'ں',
+            'ہہ': 'ہ',
+            'یی': 'ی',
+            
+            # Common phrase corrections
+            'ے لہےے': 'کے لیے',
+            'کا ے لہےے': 'کے لیے',
+            'و ہےہ': 'کو',
+            'ہےقہےن': 'یقین',
+            'اکہےلے': 'اکیلے',
+            'نہہےں': 'نہیں',
+            'ہہےں': 'ہیں',
+            'کا ے': 'کے',
+            'ساتھ ہہےں': 'ساتھ ہیں',
+            'تجوہےز': 'تجویز',
+            'ضرورہے': 'ضروری',
+            'بارے مہےں': 'بارے میں',
+            'کرہےں': 'کریں',
+            'بہترہےن': 'بہترین',
+            'ہے مدد': 'کی مدد',
+            'خوشہے': 'خوشی',
+            'ترجہےح': 'ترجیح',
+            'جسے سے': 'جس سے',
+            
+            # Medical term corrections
+            'برہےسٹ': 'بریسٹ',
+            'کہےموتھراپہے': 'کیموتھراپی',
+            'متلہے': 'متلی',
+            'غذائہےں': 'غذائیں',
+            'چربہے': 'چربی',
+            'ہلکے': 'ہلکی',
+            'آسانہے': 'آسانی',
+            'ہائہےڈرہےٹنگ': 'ہائیڈریٹنگ',
+            'ہائہےڈرہےٹڈ': 'ہائیڈریٹڈ',
+            
+            # Grammar and structure fixes
+            'کرنےے': 'کرنے',
+            'ہونےے': 'ہونے',
+            'سکتےے': 'سکتے',
+            'سکتیی': 'سکتی',
+            'والےے': 'والے',
+            'والیی': 'والی',
+            'کہے': 'کے',
+            'ہےے': 'ہے',
+            
+            # Common word fixes
+            'ام ': 'ہوں ',
+            'می ': 'میں ',
+            'آپ ک': 'آپ کا ',
+            'دوران ': 'دوران ',
+            'عام ': 'عام ',
+            'مسئل ': 'مسئلہ ',
+            'اس ': 'اس ',
+            'کو ': 'کو ',
+            'کرن ': 'کرنے ',
+            'س ': 'سے ',
+            'طریق ': 'طریقے ',
+            'بتا ': 'بتا ',
+            'سکتی ': 'سکتی ',
+            'اکٹر': 'ڈاکٹر',
+            'اکیل': 'اکیلے',
+            'میش': 'میں',
+            'وتی': 'ہوتی',
+            'لکی': 'ہلکی',
+            'بتر': 'بہتر',
+            'محفوظ ر': 'محفوظ رکھتی ہے',
+            'رشت': 'رشتہ داروں',
+        }
+        
+        # Apply spelling corrections iteratively
+        for wrong, correct in spelling_corrections.items():
+            text = text.replace(wrong, correct)
+        
+        # Fix common grammatical patterns using regex for better coverage
+        import re
+        
+        # Fix character repetition patterns
+        repetition_patterns = [
+            (r'ہہ', 'ہ'),
+            (r'یی', 'ی'),
+            (r'ےے', 'ے'),
+            (r'ںں', 'ں'),
+            (r'کک', 'ک'),
+            (r'گگ', 'گ'),
+        ]
+        
+        for pattern, replacement in repetition_patterns:
+            text = re.sub(pattern, replacement, text)
+        
+        # Fix common grammatical patterns
+        grammatical_fixes = [
+            ('ک دوران', 'کے دوران'),
+            ('ک بار', 'کے بارے'),
+            ('ک بعد', 'کے بعد'),
+            ('ک لی', 'کے لیے'),
+            ('ک ساتھ', 'کے ساتھ'),
+            ('ک طور', 'کے طور'),
+            ('ک ذریع', 'کے ذریعے'),
+            ('ک مطابق', 'کے مطابق'),
+        ]
+        
+        for wrong, correct in grammatical_fixes:
+            text = text.replace(wrong, correct)
+        
+        # Fix spacing and punctuation issues
+        text = re.sub(r'\s+', ' ', text)  # Multiple spaces to single space
+        text = re.sub(r' \.', '.', text)  # Space before period
+        text = re.sub(r' ،', '،', text)   # Space before comma
+        text = re.sub(r'  ', ' ', text)   # Double spaces
+        text = re.sub(r'۔۔', '۔', text)   # Double periods
+        
+        # Ensure sentence completion and structure
+        sentences = text.split('۔')
+        cleaned_sentences = []
+        
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if sentence and len(sentence.split()) >= 2:  # At least 2 words
+                # Ensure sentence starts properly (no hanging characters)
+                if sentence and sentence[0] in [' ', '،', '۔']:
+                    sentence = sentence[1:].strip()
+                if sentence:
+                    cleaned_sentences.append(sentence)
+        
+        # Reconstruct text with proper punctuation
+        if cleaned_sentences:
+            text = '۔ '.join(cleaned_sentences) + '۔'
+        else:
+            text = text.strip()
+        
+        # Final normalization
+        text = text.strip()
+        
+        return text
+
+    def _detect_emotional_needs(self, user_query: str, language: str = "english") -> dict:
+        """Enhanced emotional need detection with better Urdu support"""
+        query_lower = user_query.lower()
+        
+        # Emotional triggers in both languages
+        emotional_triggers_english = [
+            "scared", "afraid", "worried", "anxious", "fear", "nervous", "stressed",
+            "overwhelmed", "depressed", "sad", "lonely", "alone", "hopeless",
+            "can't cope", "struggling", "difficult", "hard time", "suffering",
+            "terrified", "panic", "breakdown", "crying", "tears", "misery"
+        ]
+        
+        emotional_triggers_urdu = [
+            "خوف", "ڈر", "پریشانی", "فکر", "تنہائی", "اداسی", "مایوسی", "تکلیف",
+            "گھبراہٹ", "بے چینی", "بے بسی", "رونا", "آنسو", "دکھ", "غم",
+            "ہمت", "طاقت", "حوصلہ", "پرسکون", "سکون", "چین"
+        ]
+        
+        # Information triggers
+        info_triggers_english = [
+            "what", "how", "when", "where", "which", "why", 
+            "treatment", "medication", "exercise", "diet", "symptoms", 
+            "pain", "side effects", "recovery", "diagnosis", "procedure"
+        ]
+        
+        info_triggers_urdu = [
+            "کیا", "کیسے", "کب", "کہاں", "کون سا", "کیوں", "کس طرح",
+            "علاج", "دوا", "ورزش", "غذا", "علامات", "درد", "مراحل",
+            "طریقہ", "عمل", "تفصیل", "معلومات"
+        ]
+        
+        if language == "urdu":
+            emotional_triggers = emotional_triggers_urdu
+            info_triggers = info_triggers_urdu
+        else:
+            emotional_triggers = emotional_triggers_english
+            info_triggers = info_triggers_english
+        
+        emotional_score = sum(1 for trigger in emotional_triggers if trigger in query_lower)
+        info_score = sum(1 for trigger in info_triggers if trigger in query_lower)
+        
+        return {
+            "needs_emotional_support": emotional_score > 0,
+            "needs_information": info_score > 0,
+            "emotional_score": emotional_score,
+            "info_score": info_score
+        }
+
+    def _add_emotional_support(self, response: str, user_query: str, language: str = "english") -> str:
+        """Add natural emotional support integrated into the response"""
+        emotional_needs = self._detect_emotional_needs(user_query, language)
+        
+        # Always add some level of emotional support, but more if detected
+        if language == "urdu":
+            if emotional_needs["needs_emotional_support"]:
+                # Strong emotional support phrases
+                support_phrases = [
+                    "آپ کی طاقت قابلِ تعریف ہے، اور میں آپ کے ساتھ ہوں۔",
+                    "یہ مشکل وقت ہے، لیکن آپ اکیلے نہیں ہیں۔ ہم مل کر اس کا سامنا کریں گے۔",
+                    "آپ کی ہمت اور صبر کو سلام، بہتر دن ضرور آئیں گے۔",
+                ]
+            else:
+                # Gentle emotional support phrases
+                support_phrases = [
+                    "آپ کی صحت اور خوشی ہماری پہلی ترجیح ہے۔",
+                    "یقین رکھیں، ہر طوفان کے بعد سکون ضرور آتا ہے۔",
+                    "آپ جیسے بہادر لوگ ہی دنیا کو روشن کرتے ہیں۔",
+                ]
+        else:
+            if emotional_needs["needs_emotional_support"]:
+                # Strong emotional support phrases
+                support_phrases = [
+                    "Your strength is truly admirable, and I'm here with you every step of the way.",
+                    "This is a challenging time, but you're not alone. We'll face this together.",
+                    "I want you to know how much courage you're showing, and better days will come.",
+                ]
+            else:
+                # Gentle emotional support phrases
+                support_phrases = [
+                    "Your wellbeing and happiness are my top priority right now.",
+                    "Please remember that after every storm comes calm.",
+                    "People like you, with such resilience, truly light up the world.",
+                ]
+        
+        # Choose a support phrase that fits naturally
+        support_text = random.choice(support_phrases)
+        
+        # Integrate support naturally - for Urdu, place at beginning for impact
+        if language == "urdu":
+            if support_text not in response:
+                # Check if response already has emotional content
+                if not any(phrase in response for phrase in ['طاقت', 'ہمت', 'حوصلہ', 'سکون', 'خوشی']):
+                    return f"{support_text}\n\n{response}"
+        else:
+            if support_text not in response:
+                # Check if response already has emotional content
+                if not any(phrase in response for phrase in ['strength', 'courage', 'hope', 'together', 'proud']):
+                    return f"{support_text}\n\n{response}"
+        
+        return response
+    
+    def retrieve_relevant_chunks(self, user_query: str, language: str = "english") -> List[Any]:
+        """Retrieve relevant chunks with language-specific prioritization"""
+        if not hasattr(self, 'retriever') or self.retriever is None:
+            print("❌ Retriever not available")
+            return []
+        
+        try:
+            if language == "urdu":
+                print("🔍 Prioritizing Urdu content for Urdu query...")
+                from llama_index.core.vector_stores import MetadataFilter, MetadataFilters
+                urdu_filter = MetadataFilter(key="language", value="urdu")
+                urdu_results = self.retriever.retrieve(
+                    user_query, 
+                    filters=MetadataFilters(filters=[urdu_filter])
+                )
+                
+                quality_threshold = 0.5
+                high_quality_urdu = [
+                    result for result in urdu_results 
+                    if hasattr(result, 'score') and result.score >= quality_threshold
+                ]
+                
+                if high_quality_urdu:
+                    print(f"✅ Found {len(high_quality_urdu)} high-quality Urdu chunks")
+                    return high_quality_urdu[:5]
+                elif urdu_results:
+                    print(f"⚠️ Using {len(urdu_results)} lower-confidence Urdu chunks")
+                    return urdu_results[:3]
+                
+                print("🔍 No Urdu content found, searching all content...")
+            
+            retrieval_results = self.retriever.retrieve(user_query)
+            quality_threshold = 0.5
+            high_quality_results = [
+                result for result in retrieval_results 
+                if hasattr(result, 'score') and result.score >= quality_threshold
+            ]
+            
+            if not high_quality_results and retrieval_results:
+                print("⚠️ Using lower confidence results")
+                return retrieval_results[:3]
+            
+            print(f"✅ Retrieved {len(high_quality_results)} relevant chunks")
+            return high_quality_results[:5]
+            
+        except Exception as e:
+            print(f"❌ Retrieval error: {e}")
+            return []
+    
+    def build_concise_prompt(self, user_query: str, context_chunks: List[Any], language: str = "english") -> str:
+        """Build prompt for concise, targeted responses with emotional intelligence"""
+        
+        context_text = ""
+        if context_chunks:
+            context_parts = []
+            for i, chunk in enumerate(context_chunks[:2]):
+                chunk_text = chunk.text if hasattr(chunk, 'text') else str(chunk)
+                key_points = " ".join(chunk_text.split()[:100])
+                context_parts.append(f"CONTEXT {i+1}: {key_points}")
+            context_text = "\n".join(context_parts)
+
+        # Analyze emotional and information needs
+        needs_analysis = self._detect_emotional_needs(user_query, language)
+        
+        if language == "urdu":
+            prompt = f"""
+# WELL BEING AGENT - BREAST CANCER SUPPORT
+# CRITICAL: RESPOND ONLY IN URDU LANGUAGE USING CORRECT URDU SPELLING AND GRAMMAR
+# ABSOLUTELY NO HINDI, ARABIC, OR OTHER LANGUAGES - PURE URDU ONLY
+
+## PATIENT'S QUERY:
+"{user_query}"
+
+## EMOTIONAL ANALYSIS:
+- Needs Emotional Support: {'YES' if needs_analysis['needs_emotional_support'] else 'NO'}
+- Needs Information: {'YES' if needs_analysis['needs_information'] else 'NO'}
+
+## CONTEXT (USE IF RELEVANT):
+{context_text if context_text else "General breast cancer knowledge"}
+
+## CRITICAL SPELLING RULES - MUST FOLLOW:
+1. ✅ "مجھے" ❌ "مجہے"
+2. ✅ "پروگرام" ❌ "پروگرہوں"  
+3. ✅ "کینسر" ❌ "کہےنسر"
+4. ✅ "ڈاکٹر" ❌ "ڈڈاکٹر"
+5. ✅ "ہے" ❌ "ہےہ"
+6. ✅ "میں" ❌ "مہےں"
+7. ✅ "کے لیے" ❌ "کا ے لہےے"
+8. ✅ "جس سے" ❌ "جسے سے"
+
+## RESPONSE REQUIREMENTS - URDU:
+1. **LANGUAGE:** صرف اردو میں جواب دیں، درست ہجے اور قواعد کا استعمال کریں
+2. **EMOTIONAL TONE:** ہمدردانہ، گرمجوش، اور امید بخش انداز اپنائیں
+3. **CONTENT:** اگر معلومات درکار ہوں تو واضح، درست معلومات دیں
+4. **SUPPORT:** جذباتی مدد قدرتی طور پر پیش کریں، الگ سے ذکر نہ کریں
+5. **LENGTH:** 4-6 جملے، مختصر مگر جامع
+6. **SPELLING:** درست اردو ہجے استعمال کریں، غلط ہجے سے پرہیز کریں
+7. **COMPLETENESS:** مکمل جملے لکھیں، ادھورے جملے نہ چھوڑیں
+
+## آپ کا گرمجوش، درست اردو میں اور مکمل جواب:
+"""
+        else:
+            prompt = f"""
+# WELL BEING AGENT - BREAST CANCER SUPPORT
+
+## PATIENT'S QUERY:
+"{user_query}"
+
+## EMOTIONAL ANALYSIS:
+- Needs Emotional Support: {'YES' if needs_analysis['needs_emotional_support'] else 'NO'}
+- Needs Information: {'YES' if needs_analysis['needs_information'] else 'NO'}
+
+## CONTEXT (USE IF RELEVANT):
+{context_text if context_text else "General breast cancer knowledge"}
+
+## RESPONSE REQUIREMENTS:
+
+1. **TONE:** Warm, compassionate, and hopeful
+2. **CONTENT:** Provide accurate information if needed
+3. **SUPPORT:** Integrate emotional support naturally without explicitly stating it
+4. **LENGTH:** 4-6 sentences, concise but comprehensive
+5. **FOCUS:** Be caring and present with the patient
+6. **COMPLETENESS:** Write complete sentences, no incomplete thoughts
+
+## YOUR COMPASSIONATE RESPONSE:
+"""
+        
+        return prompt.strip()
+    
+    def build_urdu_prompt(self, user_query: str, context_chunks: List[Any]) -> str:
+        """Build detailed prompt for Urdu responses with strong language enforcement"""
+        context_text = ""
+        if context_chunks:
+            context_parts = []
+            for i, chunk in enumerate(context_chunks[:3]):
+                chunk_text = chunk.text if hasattr(chunk, 'text') else str(chunk)
+                source_topic = chunk.metadata.get('topic', 'General Information') if hasattr(chunk, 'metadata') else 'General Information'
+                context_parts.append(f"SOURCE {i+1} - {source_topic}:\n{chunk_text}")
+            context_text = "\n\n".join(context_parts)
+        
+        urdu_prompt = f"""
+# WELL BEING AGENT - BREAST CANCER SUPPORT
+# CRITICAL: RESPOND ONLY IN URDU LANGUAGE WITH PERFECT SPELLING
+# ABSOLUTELY NO HINDI, ARABIC, OR ENGLISH - PURE URDU ONLY
+
+## YOUR ROLE IN URDU:
+آپ بریسٹ کینسر کی سپیشلائزڈ ویل بینگ ایجنٹ ہیں۔ آپ مریضوں کو نہ صرف طبی معلومات بلکہ قدرتی طور پر جذباتی مدد اور ہمت بھی فراہم کرتی ہیں۔
+
+## AVAILABLE CONTEXT:
+{context_text if context_text else "General breast cancer knowledge"}
+
+## USER'S QUESTION (IN URDU):
+"{user_query}"
+
+## CRITICAL SPELLING RULES - MUST FOLLOW:
+1. ✅ "مجھے" ❌ "مجہے"
+2. ✅ "پروگرام" ❌ "پروگرہوں"  
+3. ✅ "کینسر" ❌ "کہےنسر"
+4. ✅ "ڈاکٹر" ❌ "ڈڈاکٹر"
+5. ✅ "ہے" ❌ "ہےہ"
+6. ✅ "میں" ❌ "مہےں"
+7. ✅ "کے لیے" ❌ "کا ے لہےے"
+8. ✅ "جس سے" ❌ "جسے سے"
+
+## RESPONSE REQUIREMENTS - URDU:
+1. **LANGUAGE ENFORCEMENT:** صرف اور صرف اردو میں جواب دیں
+2. **SPELLING ACCURACY:** درست اردو ہجے استعمال کریں، عام غلطیوں سے پرہیز کریں
+3. **EMOTIONAL INTEGRATION:** جذباتی مدد کو قدرتی انداز میں پیش کریں
+4. **COMPASSIONATE TONE:** گرمجوش، ہمدردانہ، اور امید بخش انداز
+5. **INFORMATION ACCURACY:** سیاق و سباق کے مطابق درست معلومات دیں
+6. **COMPLETE SENTENCES:** مکمل جملے لکھیں، ادھورے جملے نہ چھوڑیں
+
+## EXAMPLES OF CORRECT URDU:
+- ✅ "بریسٹ کینسر کے بارے میں معلومات حاصل ��رنا ایک اہم قدم ہے۔"
+- ✅ "میں آپ کو درست معلومات فراہم کرنے کی کوشش کروں گی۔"
+- ✅ "آپ کے سوال کا جواب دینے میں مجھے خوشی ہو رہی ہے۔"
+
+## آپ کا درست ہجے، مکمل جملوں اور ہمدردانہ انداز میں جواب:
+"""
+        return urdu_prompt.strip()
+    
+    def build_enhanced_prompt(self, user_query: str, context_chunks: List[Any]) -> str:
+        """Build prompt for English responses with emotional intelligence"""
+        context_text = ""
+        if context_chunks:
+            context_parts = []
+            for i, chunk in enumerate(context_chunks[:3]):
+                chunk_text = chunk.text if hasattr(chunk, 'text') else str(chunk)
+                source_topic = chunk.metadata.get('topic', 'General Information') if hasattr(chunk, 'metadata') else 'General Information'
+                context_parts.append(f"SOURCE {i+1} - {source_topic}:\n{chunk_text}")
+            context_text = "\n\n".join(context_parts)
+
+        # Analyze emotional needs
+        needs_analysis = self._detect_emotional_needs(user_query, "english")
+
+        prompt = f"""
+# WELL BEING AGENT - BREAST CANCER SUPPORT
+
+## YOUR ROLE
+You are a compassionate Well Being Agent specializing in breast cancer support. You provide supportive information, emotional comfort, and evidence-based guidance.
+
+## EMOTIONAL ANALYSIS:
+- Patient Needs Emotional Support: {'YES' if needs_analysis['needs_emotional_support'] else 'NO'}
+- Patient Needs Information: {'YES' if needs_analysis['needs_information'] else 'NO'}
+
+## RESPONSE GUIDELINES
+- **Tone**: Warm, supportive, compassionate, and hopeful
+- **Emotional Integration**: Naturally incorporate emotional support without explicitly stating it
+- **Information**: Provide evidence-based guidance when needed
+- **Presence**: Be fully present and caring with the patient
+- **Completeness**: Write complete sentences, no incomplete thoughts
+
+## AVAILABLE CONTEXT
+{context_text if context_text else "General breast cancer knowledge"}
+
+## USER'S QUESTION
+"{user_query}"
+
+## RESPONSE REQUIREMENTS
+1. If emotional support is needed: Integrate comfort and hope naturally into your response
+2. If information is needed: Provide clear, accurate guidance
+3. Always acknowledge the patient's strength implicitly
+4. Maintain a caring, present tone throughout
+5. Keep response concise but comprehensive (4-6 complete sentences)
+
+## YOUR COMPASSIONATE RESPONSE:
+"""
+        return prompt.strip()
+    
+    def query_llm_with_retry(self, prompt: str, language: str = "english", max_retries: int = 3) -> str:
+        """Enhanced LLM query using OpenAI client format"""
+        if not config.api_key:
+            print("❌ No API key available")
+            return config.FALLBACK_MESSAGE
+        
+        # Enhanced system message with Urdu-specific instructions
+        if language == "urdu":
+            system_message = """آپ بریسٹ کینسر کی سپیشلائزڈ ویل بینگ ایجنٹ ہیں۔ 
+
+CRITICAL URDU LANGUAGE RULES:
+1. صرف اور صرف اردو میں جواب دیں
+2. ہر لفظ کے ہجے درست ہوں
+3. مکمل اور واضح جملے استعمال کریں
+4. غلط ہجے اور ادھورے جملوں سے پرہیز کریں
+5. طبی معلومات درست اور واضح ہوں
+
+مثال کے طور پر:
+✅ "بریسٹ کینسر کے علاج کے مختلف طریقے ہیں۔"
+❌ "برہےسٹ کہےنسر کا علاچ کہے طرح ہےہ۔"
+
+جذباتی مدد قدرتی طور پر پیش کریں اور مریض کی طاقت کو تسلیم کریں۔"""
+        else:
+            system_message = """You are a compassionate Well Being Agent for breast cancer support. Provide direct, helpful information while naturally integrating emotional support. Always maintain a warm, hopeful, and caring tone. Ensure complete sentences and clear information."""
+    
+        for attempt in range(max_retries):
+            try:
+                # Initialize OpenAI client with OpenRouter configuration
+                client = OpenAI(
+                    base_url="https://openrouter.ai/api/v1",
+                    api_key=config.api_key,
+                )
+
+                # Adjust parameters for better Urdu quality
+                temperature = 0.2 if language == "urdu" else 0.3
+                max_tokens = 500 if language == "urdu" else config.MAX_TOKENS
+                
+                print(f"🔄 Sending request to {config.MODEL_PROVIDER} (attempt {attempt + 1})")
+                
+                completion = client.chat.completions.create(
+                    extra_headers={
+                        "HTTP-Referer": "https://huggingface.co",
+                        "X-Title": "Well Being Agent",
+                    },
+                    extra_body={},
+                    model=config.MODEL_ID,
+                    messages=[
+                        {
+                            "role": "system",
+                            "content": system_message
+                        },
+                        {
+                            "role": "user", 
+                            "content": prompt
+                        }
+                    ],
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                )
+                
+                response_text = completion.choices[0].message.content
+                print("✅ LLM response received")
+                
+                # For Urdu, do immediate quality check
+                if language == "urdu":
+                    if self._is_urdu_response_corrupted(response_text):
+                        print("⚠️ Urdu response appears corrupted, applying enhanced cleaning")
+                        
+                return response_text
+                
+            except Exception as e:
+                print(f"❌ Request failed: {e}")
+                if "429" in str(e):
+                    wait_time = 2 ** attempt
+                    print(f"⏳ Rate limited. Waiting {wait_time} seconds...")
+                    time.sleep(wait_time)
+                    continue
+                elif "401" in str(e) or "402" in str(e):
+                    print(f"❌ API key issue")
+                    if config.rotate_to_next_key():
+                        continue
+                    else:
+                        return config.FALLBACK_MESSAGE
+                
+                if attempt == max_retries - 1:
+                    if config.rotate_to_next_key():
+                        return self.query_llm_with_retry(prompt, language, max_retries)
+                    return config.FALLBACK_MESSAGE
+                time.sleep(1)
+        
+        return config.FALLBACK_MESSAGE
+
+    def _is_urdu_response_corrupted(self, text: str) -> bool:
+        """Check if Urdu response has common corruption patterns"""
+        corruption_indicators = [
+            'ہےہ', 'مہےں', 'کہے', 'پروگرہوں', 'ڈڈاکٹر', 'کا ے لہےے', 'جسے سے'
+        ]
+        
+        for indicator in corruption_indicators:
+            if indicator in text:
+                return True
+        
+        # Check for excessive character repetition
+        import re
+        if re.search(r'(.)\1\1', text):  # Three repeated characters
+            return True
+        
+        return False
+    
+    def _verify_language_compliance(self, text: str, expected_language: str) -> str:
+        """Verify and correct language compliance"""
+        if expected_language == "urdu":
+            # Check for common incorrect language patterns
+            hindi_pattern = re.compile(r'[\u0900-\u097F]+')  # Hindi characters
+            arabic_pattern = re.compile(r'[\uFE70-\uFEFF]+')  # Arabic specific characters
+            
+            if hindi_pattern.search(text):
+                print("⚠️ Hindi detected in Urdu response, applying correction...")
+                # Add Urdu language reminder
+                return text + "\n\nبراہ کرم صرف اردو میں جواب دیں۔"
+            
+            if arabic_pattern.search(text):
+                print("⚠️ Arabic detected in Urdu response, applying correction...")
+                # Add Urdu language reminder
+                return text + "\n\nبراہ کرم صرف اردو میں جواب دیں۔"
+                
+        return text
+    
+    def format_final_response(self, llm_answer: str, language: str = "english") -> str:
+        cleaned_answer = llm_answer.strip()
+        
+        # Enhanced Urdu text cleaning
+        if language == 'urdu':
+            print("🧹 Applying advanced Urdu text cleaning...")
+            cleaned_answer = self._clean_urdu_text(cleaned_answer)
+        
+        # Verify language compliance
+        cleaned_answer = self._verify_language_compliance(cleaned_answer, language)
+        
+        if language == 'urdu':
+            gentle_reminder = "\n\nاپنی صحت کی دیکھ بھال ٹیم سے اپنے خدشات پر بات کرنا یاد رکھیں۔"
+        else:
+            gentle_reminder = "\n\nRemember to discuss any concerns with your healthcare team."
+        
+        if gentle_reminder not in cleaned_answer:
+            cleaned_answer += gentle_reminder
+        
+        return cleaned_answer.strip()
+    
+    def get_enhanced_answer(self, user_query: str, language: str = None, response_type: str = "text") -> str:
+        print(f"🔍 Processing query: '{user_query}' (Type: {response_type})")
+        
+        if language is None:
+            language = self.detect_language(user_query)
+            print(f"🌐 Detected language: {language}")
+        
+        # Special handling for problematic Urdu queries
+        if language == "urdu":
+            problematic_patterns = ['اوج ایک انسر', 'اصلاح ملکم', 'نعم']
+            if any(pattern in user_query for pattern in problematic_patterns):
+                print("⚠️ Detected problematic query pattern, applying enhanced Urdu handling")
+        
+        chunks = self.retrieve_relevant_chunks(user_query, language)
+        
+        cache_key = response_cache.get_cache_key(user_query, chunks)
+        cached_response = response_cache.get(cache_key)
+        
+        if cached_response:
+            print("✅ Using cached response")
+            final_answer = cached_response
+        else:
+            # Enhanced prompt selection with quality focus
+            query_lower = user_query.lower()
+            wants_details = any(phrase in query_lower for phrase in [
+                "give details", "more detail", "explain more", "tell me more", 
+                "elaborate", "in detail", "detailed", "comprehensive"
+            ])
+            
+            if language == 'urdu':
+                if wants_details:
+                    prompt = self.build_urdu_prompt(user_query, chunks)
+                else:
+                    prompt = self.build_concise_prompt(user_query, chunks, language)
+            else:
+                if wants_details:
+                    prompt = self.build_enhanced_prompt(user_query, chunks)
+                else:
+                    prompt = self.build_concise_prompt(user_query, chunks, language)
+            
+            llm_answer = self.query_llm_with_retry(prompt, language)
+            
+            # Enhanced cleaning and validation for Urdu
+            if language == 'urdu':
+                original_length = len(llm_answer.strip().split())
+                llm_answer = self.format_final_response(llm_answer, language)
+                cleaned_length = len(llm_answer.strip().split())
+                
+                if cleaned_length < 5:  # Too short
+                    print("⚠️ Urdu response too short, may be incomplete")
+                elif cleaned_length < original_length * 0.7:  # Significant reduction
+                    print("⚠️ Significant text reduction during cleaning")
+            
+            final_answer = self.format_final_response(llm_answer, language)
+            
+            # Always add emotional support naturally
+            final_answer = self._add_emotional_support(final_answer, user_query, language)
+            
+            response_cache.set(cache_key, final_answer)
+            print("💾 Response cached for future use")
+        
+        # Log conversation to JSON
+        conversation_logger.log_conversation(
+            user_input=user_query,
+            llm_response=final_answer,
+            language=language,
+            response_type=response_type
+        )
+        
+        self.conversation_history.append({
+            "query": user_query, 
+            "answer": final_answer, 
+            "language": language,
+            "response_type": response_type,
+            "timestamp": time.time()
+        })
+        
+        return final_answer
+
+# === Pre-load Index at Module Level ===
+print("🚀 Starting Well Being Agent with optimized loading...")
+_start_time = time.time()
+
+print("🔄 Loading vector index...")
+index, retriever = load_index_fast()
+
+_load_time = time.time() - _start_time
+print(f"✅ System ready in {_load_time:.2f} seconds")
+
+# Create global RAG system instance
+rag_system = BreastCancerRAGSystem(index, retriever)
+
+# === Interactive Chat Mode ===
+def interactive_chat():
+    print("💬 Well Being Agent - Breast Cancer Support")
+    print("=" * 50)
+    print("Type 'quit' to exit, 'topics' to see available topics, 'cache' for cache stats")
+    print("=" * 50)
+    
+    global rag_system
+    
+    while True:
+        user_input = input("\n❓ Your question: ").strip()
+        if user_input.lower() in ['quit', 'exit', 'q']:
+            break
+        elif user_input.lower() == 'topics':
+            print("\n📚 Available topics: Fertility, Treatment, Symptoms, Diagnosis, etc.")
+            continue
+        elif user_input.lower() == 'cache':
+            print(f"\n📊 Cache stats: {len(response_cache.cache)} cached responses")
+            continue
+        elif not user_input:
+            continue
+        
+        print("🤔 Thinking...")
+        start_time = time.time()
+        answer = rag_system.get_enhanced_answer(user_input)
+        response_time = time.time() - start_time
+        print(f"\n💡 {answer}")
+        print(f"⏱️  Response time: {response_time:.2f} seconds")
+
+# === Main Function ===
+def main():
+    print("🏥 Well Being Agent - Breast Cancer Support System")
+    print("=" * 50)
+    print(f"📋 Current Configuration:")
+    print(f"   Model: {config.MODEL_ID}")
+    print(f"   Provider: {config.MODEL_PROVIDER}")
+    print(f"   Index: {config.INDEX_PATH}")
+    print(f"   Cache: {len(response_cache.cache)} responses loaded")
+    print("=" * 50)
+    
+    if not config.api_keys:
+        print("❌ API keys not configured.")
+        if IS_HUGGING_FACE:
+            print("💡 Add API keys in Space Settings → Repository secrets")
+        return
+    
+    interactive_chat()
+
+if __name__ == "__main__":
+    main()

Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install system dependencies including audio libraries
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    git \
+    ffmpeg \
+    portaudio19-dev \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p static/audio config cache
+
+# Expose port (Hugging Face uses 7860)
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Start command for Hugging Face
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

Index.py

@@ -0,0 +1,192 @@
+# Index.py - Multilingual version (English + Urdu) for creating embeddings and vector index
+import os
+import json
+import logging
+from pathlib import Path
+
+# === Centralized Configuration System ===
+class Config:
+    """Centralized configuration - loads from config.json"""
+    
+    def __init__(self):
+        # Load settings from config.json
+        self.settings = self._load_config_file()
+        
+        # Apply settings
+        self.INDEX_PATH = self.settings["index_path"]
+        self.DATASET_PATH = "DataSet/breast_cancer.json"  # Fixed path
+        self._validate_config()
+    
+    def _load_config_file(self):
+        """Load configuration from config/config.json file"""
+        config_file = os.path.join("config", "config.json")
+        default_config = {
+            "model_provider": "openrouter",
+            "model_id": "meta-llama/llama-3.3-70b-instruct:free",
+            "api_keys_folder": "config",
+            "index_path": "cancer_index_store",
+            "dataset_path": "DataSet/breast_cancer.json",
+            "similarity_top_k": 5,
+            "temperature": 0.2,
+            "max_tokens": 350,
+            "combine_sources": True,
+            "fallback_message": "Sorry, I don't know the answer.",
+            "strict_breast_cancer_only": True
+        }
+    
+        try:
+            if os.path.exists(config_file):
+                with open(config_file, 'r', encoding='utf-8') as f:
+                    loaded_config = json.load(f)
+                merged_config = {**default_config, **loaded_config}
+                logging.info("✅ Configuration loaded from config/config.json")
+                return merged_config
+            else:
+                os.makedirs(os.path.dirname(config_file), exist_ok=True)
+                with open(config_file, 'w', encoding='utf-8') as f:
+                    json.dump(default_config, f, indent=4)
+                logging.info("📁 Created default config/config.json file")
+                return default_config
+        except Exception as e:
+            logging.error(f"❌ Error loading config/config.json: {e}")
+            logging.info("🔄 Using default configuration")
+            return default_config
+    
+    def _validate_config(self):
+        """Validate configuration"""
+        if not os.path.exists(self.DATASET_PATH):
+            logging.error(f"❌ Dataset file not found: {self.DATASET_PATH}")
+            possible_locations = [
+                "DataSet/breast_cancer.json",
+                "breast_cancer.json", 
+                "data/breast_cancer.json",
+                "../DataSet/breast_cancer.json"
+            ]
+            for location in possible_locations:
+                if os.path.exists(location):
+                    logging.info(f"💡 Found dataset at: {location}")
+                    self.DATASET_PATH = location
+                    return
+        else:
+            logging.info(f"✅ Dataset found: {self.DATASET_PATH}")
+        logging.info(f"✅ Index will be stored at: {self.INDEX_PATH}")
+
+# Initialize configuration
+config = Config()
+
+# === Setup Logging ===
+logging.basicConfig(
+    level=logging.INFO, 
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler()]
+)
+
+def create_vector_index():
+    """
+    Creates embeddings and builds vector index from dataset
+    Supports both English and Urdu text.
+    """
+    try:
+        from llama_index.core import VectorStoreIndex, Document, StorageContext
+        from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+        from llama_index.core.node_parser import SimpleNodeParser
+        
+        print("🚀 Starting Multilingual Vector Index Creation...")
+        print("=" * 60)
+        
+        # Check dataset
+        if not os.path.exists(config.DATASET_PATH):
+            print(f"❌ Dataset not found: {config.DATASET_PATH}")
+            return False
+        
+        # Load dataset
+        print(f"📖 Loading dataset from: {config.DATASET_PATH}")
+        with open(config.DATASET_PATH, 'r', encoding='utf-8') as f:
+            dataset = json.load(f)
+        print(f"✅ Loaded dataset with {len(dataset)} entries")
+        
+        # Normalize dataset for multilingual consistency
+        documents = []
+        for item in dataset:
+            if isinstance(item, dict):
+                text = item.get('content') or item.get('text') or item.get('answer') or str(item)
+                if not text or len(text.strip()) < 10:
+                    continue  # skip empty
+                metadata = {k: v for k, v in item.items() if k not in ['content', 'text', 'answer']}
+                documents.append(Document(text=text.strip(), metadata=metadata))
+            else:
+                documents.append(Document(text=str(item)))
+        
+        print(f"✅ Created {len(documents)} documents for embedding")
+
+        # === Multilingual embedding model ===
+        # Supports 50+ languages including Urdu + English
+        multilingual_model = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
+        print(f"🔧 Loading embedding model: {multilingual_model}")
+        embed_model = HuggingFaceEmbedding(model_name=multilingual_model)
+        
+        # Create node parser
+        node_parser = SimpleNodeParser.from_defaults(chunk_size=512, chunk_overlap=50)
+        
+        # Parse documents
+        print("🔨 Parsing documents into nodes...")
+        nodes = node_parser.get_nodes_from_documents(documents)
+        print(f"✅ Created {len(nodes)} nodes")
+        
+        # Build index
+        print("🏗️ Building multilingual vector index...")
+        index = VectorStoreIndex(nodes=nodes, embed_model=embed_model, show_progress=True)
+        
+        # Persist
+        os.makedirs(config.INDEX_PATH, exist_ok=True)
+        print(f"💾 Saving index to: {config.INDEX_PATH}")
+        index.storage_context.persist(persist_dir=config.INDEX_PATH)
+        
+        print("✅ Multilingual vector index created successfully!")
+        print(f"📁 Index location: {config.INDEX_PATH}")
+        print(f"📊 Total nodes embedded: {len(nodes)}")
+
+        # Test retrieval in both languages
+        retriever = index.as_retriever(similarity_top_k=2)
+        print("🔍 Testing bilingual retrieval:")
+        en_test = retriever.retrieve("What are the symptoms of breast cancer?")
+        ur_test = retriever.retrieve("بریسٹ کینسر کی علامات کیا ہیں؟")
+        print(f"✅ English test retrieved {len(en_test)} results")
+        print(f"✅ Urdu test retrieved {len(ur_test)} results")
+        
+        print("\n🎉 Multilingual index ready for RAG pipeline!")
+        return True
+
+    except Exception as e:
+        print(f"❌ Failed to create multilingual vector index: {e}")
+        import traceback; traceback.print_exc()
+        return False
+
+def check_index_exists():
+    if os.path.exists(config.INDEX_PATH):
+        print(f"✅ Index already exists at: {config.INDEX_PATH}")
+        return True
+    else:
+        print(f"❌ Index not found at: {config.INDEX_PATH}")
+        return False
+
+def main():
+    print("🏥 Well Being Agent - Multilingual Index Creator")
+    print("=" * 60)
+    
+    if check_index_exists():
+        response = input("Index already exists. Recreate? (y/n): ").strip().lower()
+        if response != 'y':
+            print("Operation cancelled.")
+            return
+    
+    success = create_vector_index()
+    if success:
+        print("\n🎯 Next steps:")
+        print("1️⃣ Run Agent.py for RAG operations")
+        print("2️⃣ Run app.py for web interface")
+    else:
+        print("\n💥 Index creation failed!")
+
+if __name__ == "__main__":
+    main()

app.py

@@ -0,0 +1,449 @@
+# app.py - Enhanced with voice query support (Text responses only)
+from fastapi import FastAPI, HTTPException, UploadFile, File
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse, JSONResponse, HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from contextlib import asynccontextmanager
+import sys
+import os
+import asyncio
+import time
+import uuid
+from typing import Optional
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Add current directory to path to fix import issues
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# Global RAG system instance
+rag_system = None
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifespan context manager for startup/shutdown events"""
+    # Startup
+    global rag_system
+    try:
+        logger.info("🚀 Starting Well Being Agent...")
+        
+        # Import here to avoid circular imports
+        from Agent import load_index, BreastCancerRAGSystem
+        
+        logger.info("📋 Loading configuration and index...")
+        
+        # Add delay to ensure everything is loaded
+        await asyncio.sleep(2)
+        
+        index, retriever = load_index()
+        if index and retriever:
+            rag_system = BreastCancerRAGSystem(index, retriever)
+            logger.info("✅ RAG System initialized successfully")
+            
+            # Test the system
+            try:
+                test_answer = rag_system.get_enhanced_answer("Hello, are you working?")
+                logger.info(f"✅ System test successful: {test_answer[:50]}...")
+            except Exception as e:
+                logger.warning(f"⚠️ System test failed: {e}")
+                
+        else:
+            logger.error("❌ Failed to load index - system will not work properly")
+            rag_system = None
+            
+    except Exception as e:
+        logger.error(f"❌ Startup error: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    yield
+    
+    # Shutdown
+    logger.info("🛑 Shutting down Well Being Agent...")
+
+app = FastAPI(
+    title="Well Being Agent - Breast Cancer Support",
+    description="AI-powered breast cancer support system providing evidence-based information and emotional support",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class QueryRequest(BaseModel):
+    query: str
+    language: str = "auto"
+    response_type: str = "text"
+
+class QueryResponse(BaseModel):
+    answer: str
+    status: str
+    language: str = "english"
+
+class VoiceResponse(BaseModel):
+    text: str
+    language: str = "english"
+    status: str = "success"
+
+# Create directories if they don't exist
+os.makedirs("static/audio", exist_ok=True)
+logger.info(f"📁 Created directory structure: static/audio")
+logger.info(f"📁 Current working directory: {os.getcwd()}")
+
+# Serve static files
+try:
+    app.mount("/static", StaticFiles(directory="static"), name="static")
+    logger.info("✅ Static files mounted successfully")
+except Exception as e:
+    logger.error(f"❌ Failed to mount static files: {e}")
+
+# Frontend serving
+@app.get("/")
+async def serve_frontend():
+    """Serve the main frontend page"""
+    try:
+        if not os.path.exists('index.html'):
+            logger.error("❌ index.html not found!")
+            fallback_html = """
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <title>Well Being Agent - System Running</title>
+                <style>
+                    body { font-family: Arial, sans-serif; margin: 40px; background: #f5f5f5; }
+                    .container { max-width: 800px; margin: 0 auto; background: white; padding: 30px; border-radius: 15px; box-shadow: 0 5px 15px rgba(0,0,0,0.1); }
+                    .status { color: green; font-weight: bold; }
+                    .error { color: red; }
+                </style>
+            </head>
+            <body>
+                <div class="container">
+                    <h1>🚀 Well Being Agent - Backend Running</h1>
+                    <p class="status">✅ Server is running successfully</p>
+                    <p class="error">⚠️ index.html file not found</p>
+                    <p>Current directory: """ + os.getcwd() + """</p>
+                    <p>Static audio directory: """ + str(os.path.exists('static/audio')) + """</p>
+                </div>
+            </body>
+            </html>
+            """
+            return HTMLResponse(content=fallback_html, status_code=200)
+        
+        return FileResponse('index.html')
+        
+    except Exception as e:
+        logger.error(f"❌ Error serving frontend: {e}")
+        return JSONResponse(
+            {"error": "Frontend serving failed", "details": str(e)}, 
+            status_code=500
+        )
+
+@app.get("/styles.css")
+async def serve_css():
+    """Serve CSS file"""
+    try:
+        if os.path.exists('styles.css'):
+            return FileResponse('styles.css', media_type='text/css')
+        else:
+            return JSONResponse({"error": "CSS file not found"}, status_code=404)
+    except Exception as e:
+        return JSONResponse({"error": "CSS serving failed"}, status_code=500)
+
+@app.get("/script.js")
+async def serve_js():
+    """Serve JavaScript file"""
+    try:
+        if os.path.exists('script.js'):
+            return FileResponse('script.js', media_type='application/javascript')
+        else:
+            return JSONResponse({"error": "JavaScript file not found"}, status_code=404)
+    except Exception as e:
+        return JSONResponse({"error": "JavaScript serving failed"}, status_code=500)
+
+@app.post("/ask-query", response_model=QueryResponse)
+async def ask_query(request: QueryRequest):
+    """Main endpoint for processing queries"""
+    try:
+        if not rag_system:
+            return QueryResponse(
+                answer="I'm currently initializing. Please wait a moment and try again.",
+                status="error",
+                language="english"
+            )
+        
+        if not request.query or not request.query.strip():
+            return QueryResponse(
+                answer="Please enter a question about breast cancer support.",
+                status="error",
+                language="english"
+            )
+        
+        # Determine language
+        if request.language == "auto":
+            detected_language = rag_system.detect_language(request.query)
+        else:
+            detected_language = request.language
+        
+        logger.info(f"🌐 Processing query in {detected_language}, Type: {request.response_type}")
+        
+        # Process the query with response type
+        answer = rag_system.get_enhanced_answer(
+            user_query=request.query, 
+            language=detected_language,
+            response_type=request.response_type
+        )
+        
+        return QueryResponse(
+            answer=answer,
+            status="success",
+            language=detected_language
+        )
+        
+    except Exception as e:
+        logger.error(f"Error processing query: {e}")
+        return QueryResponse(
+            answer="I apologize, but I'm having trouble processing your request right now. Please try again in a moment.",
+            status="error",
+            language="english"
+        )
+
+@app.post("/voice-query", response_model=VoiceResponse)
+async def process_voice_query(
+    file: UploadFile = File(...),
+    language: str = "auto"  # Auto-detect language from speech
+):
+    """Process voice query and return TEXT response only (English & Urdu)"""
+    try:
+        # Validate file type
+        if not file.content_type or not file.content_type.startswith('audio/'):
+            raise HTTPException(status_code=400, detail="File must be an audio file")
+        
+        logger.info(f"🎤 Processing voice query - Language preference: {language}")
+        
+        # Import audio processor with proper error handling
+        try:
+            from audio_processor import audio_processor
+        except ImportError as e:
+            logger.error(f"❌ Failed to import audio_processor: {e}")
+            return VoiceResponse(
+                text="Audio processing service is currently unavailable.",
+                status="error",
+                language="english"
+            )
+        
+        # Convert speech to text with language detection
+        stt_result = await audio_processor.speech_to_text(file, language)
+        
+        if not stt_result or not stt_result.get('text'):
+            raise HTTPException(status_code=400, detail="Could not transcribe audio")
+        
+        query_text = stt_result['text']
+        detected_language = stt_result.get('language', 'english')
+        
+        logger.info(f"📝 Transcribed text ({detected_language}): {query_text}")
+        
+        # Process the query through RAG system
+        if not rag_system:
+            return VoiceResponse(
+                text="System is initializing. Please try again in a moment.",
+                status="error",
+                language=detected_language
+            )
+        
+        # ✅ Always use TEXT response type for voice queries
+        answer = rag_system.get_enhanced_answer(
+            user_query=query_text,
+            language=detected_language,  # Use detected language
+            response_type="text"  # Always text response
+        )
+        
+        logger.info(f"✅ Voice query processed successfully - Response in {detected_language}")
+        
+        return VoiceResponse(
+            text=answer,  # Always return text
+            language=detected_language,
+            status="success"
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error processing voice query: {e}")
+        return VoiceResponse(
+            text="Sorry, I encountered an error processing your voice message.",
+            status="error",
+            language="english"
+        )
+
+# Audio serving endpoint (kept for any future use)
+@app.get("/audio/{filename}")
+async def serve_audio_direct(filename: str):
+    """Direct audio serving endpoint"""
+    try:
+        audio_path = os.path.join("static", "audio", filename)
+        logger.info(f"🔍 Direct audio request for: {filename}")
+        
+        if not os.path.exists(audio_path):
+            logger.error(f"❌ Audio file not found: {audio_path}")
+            raise HTTPException(status_code=404, detail=f"Audio file {filename} not found")
+        
+        # Determine content type
+        if filename.endswith('.mp3'):
+            media_type = "audio/mpeg"
+        elif filename.endswith('.wav'):
+            media_type = "audio/wav"
+        else:
+            media_type = "audio/mpeg"
+        
+        logger.info(f"🔊 Serving audio file: {audio_path}")
+        return FileResponse(audio_path, media_type=media_type, filename=filename)
+        
+    except Exception as e:
+        logger.error(f"❌ Error serving audio file: {e}")
+        raise HTTPException(status_code=500, detail="Error serving audio file")
+
+@app.get("/debug-audio")
+async def debug_audio():
+    """Debug endpoint to check audio file locations"""
+    import glob
+    
+    audio_info = {
+        "current_directory": os.getcwd(),
+        "static_directory_exists": os.path.exists("static"),
+        "static_audio_exists": os.path.exists("static/audio"),
+        "audio_files_in_static_audio": [],
+        "static_files_mounted": True
+    }
+    
+    # Check static/audio directory
+    if os.path.exists("static/audio"):
+        audio_files = glob.glob("static/audio/*.mp3") + glob.glob("static/audio/*.wav")
+        audio_info["audio_files_in_static_audio"] = [
+            {
+                "name": os.path.basename(f),
+                "size": os.path.getsize(f),
+                "path": f,
+                "absolute_path": os.path.abspath(f),
+            }
+            for f in audio_files
+        ]
+    
+    return JSONResponse(audio_info)
+
+@app.get("/predefined-questions")
+async def get_predefined_questions(language: str = "english"):
+    """Get predefined questions for breast cancer patients"""
+    try:
+        if not rag_system:
+            return JSONResponse({
+                "questions": [],
+                "status": "system_initializing"
+            })
+        
+        questions = rag_system.get_predefined_questions(language)
+        return JSONResponse({
+            "questions": questions,
+            "status": "success",
+            "language": language
+        })
+        
+    except Exception as e:
+        logger.error(f"Error getting predefined questions: {e}")
+        return JSONResponse({
+            "questions": [],
+            "status": "error"
+        })
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    health_status = {
+        "status": "healthy" if rag_system else "initializing",
+        "rag_system_loaded": rag_system is not None,
+        "service": "Well Being Agent - Breast Cancer Support",
+        "version": "1.0.0"
+    }
+    
+    return JSONResponse(health_status)
+
+@app.get("/info")
+async def system_info():
+    """System information endpoint"""
+    info = {
+        "name": "Well Being Agent",
+        "description": "AI-powered breast cancer support system",
+        "version": "1.0.0",
+        "status": "ready" if rag_system else "initializing",
+        "features": [
+            "Breast cancer information",
+            "Treatment guidance", 
+            "Fertility options",
+            "Recovery timelines",
+            "Emotional support",
+            "Multilingual support (English/Urdu)",
+            "Voice query support (Text responses)"
+        ]
+    }
+    return JSONResponse(info)
+
+# Debug endpoint to check file existence
+@app.get("/debug-files")
+async def debug_files():
+    """Check if required files exist"""
+    files = {
+        'index.html': os.path.exists('index.html'),
+        'styles.css': os.path.exists('styles.css'),
+        'script.js': os.path.exists('script.js'),
+        'Agent.py': os.path.exists('Agent.py'),
+        'audio_processor.py': os.path.exists('audio_processor.py'),
+        'current_directory': os.getcwd()
+    }
+    return JSONResponse(files)
+
+async def cleanup_old_audio_files():
+    """Clean up audio files older than 1 hour"""
+    while True:
+        try:
+            audio_dir = os.path.join("static", "audio")
+            if os.path.exists(audio_dir):
+                current_time = time.time()
+                for filename in os.listdir(audio_dir):
+                    file_path = os.path.join(audio_dir, filename)
+                    if os.path.isfile(file_path):
+                        # Delete files older than 1 hour
+                        if current_time - os.path.getctime(file_path) > 3600:
+                            os.remove(file_path)
+                            logger.info(f"🧹 Cleaned up old audio file: {filename}")
+        except Exception as e:
+            logger.error(f"Error cleaning up audio files: {e}")
+        
+        await asyncio.sleep(3600)
+
+# Start cleanup task when app starts
+@app.on_event("startup")
+async def start_cleanup_task():
+    asyncio.create_task(cleanup_old_audio_files())
+
+# Fallback route for SPA
+@app.get("/{full_path:path}")
+async def serve_frontend_fallback(full_path: str):
+    """Fallback to serve index.html for SPA routing"""
+    if os.path.exists(full_path) and full_path != "":
+        return FileResponse(full_path)
+    return FileResponse('index.html')
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 8000))
+    logger.info(f"🌐 Starting Well Being Agent Server on port {port}...")
+    uvicorn.run(app, host="0.0.0.0", port=port, log_level="info")

audio_processor.py

@@ -0,0 +1,301 @@
+# audio_processor.py - FREE TTS and STT for English AND Urdu voice notes
+import os
+import tempfile
+import logging
+import time
+from typing import Optional, Dict, Any
+from fastapi import HTTPException, UploadFile
+import uuid
+import re
+
+logger = logging.getLogger(__name__)
+
+class AudioProcessor:
+    """FREE Audio processing system for STT and TTS functionality (English + Urdu ONLY)"""
+    
+    def __init__(self):
+        self.supported_languages = ["english", "urdu"]
+        logger.info("🎵 FREE Audio Processor initialized - Supporting English & Urdu ONLY")
+    
+    async def speech_to_text(self, audio_file: UploadFile, language: str = "auto") -> Dict[str, Any]:
+        """
+        Convert speech to text using FREE STT services for English AND Urdu ONLY
+        """
+        try:
+            logger.info(f"🎤 Converting speech to text - Language: {language}")
+            
+            # Read audio file
+            audio_content = await audio_file.read()
+            
+            # Try local Whisper for multilingual support
+            stt_result = await self._try_whisper_stt(audio_content, language)
+            if stt_result:
+                # Verify detected language is only Urdu or English
+                detected_language = self._strict_detect_language_from_text(stt_result["text"])
+                if detected_language not in ["english", "urdu"]:
+                    logger.warning(f"⚠️ Detected non-supported language: {detected_language}, treating as English")
+                    detected_language = "english"
+                
+                stt_result["language"] = detected_language
+                return stt_result
+            
+            # Fallback to SpeechRecognition with Google Web API (mainly English)
+            stt_result = await self._try_speech_recognition(audio_content)
+            if stt_result:
+                detected_language = self._strict_detect_language_from_text(stt_result["text"])
+                if detected_language not in ["english", "urdu"]:
+                    detected_language = "english"
+                
+                stt_result["language"] = detected_language
+                return stt_result
+            
+            raise HTTPException(status_code=400, detail="No FREE STT service available")
+            
+        except Exception as e:
+            logger.error(f"❌ STT Error: {e}")
+            raise HTTPException(status_code=500, detail=f"Speech recognition failed: {str(e)}")
+    
+    async def _try_whisper_stt(self, audio_content: bytes, language: str = "auto") -> Optional[Dict[str, Any]]:
+        """Try local Whisper model with strict language filtering"""
+        try:
+            import whisper
+            
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(suffix=".webm", delete=False) as temp_audio:
+                temp_audio.write(audio_content)
+                temp_audio_path = temp_audio.name
+            
+            try:
+                logger.info("🔊 Using local Whisper (English/Urdu)...")
+                model = whisper.load_model("base")
+                
+                # Set language parameter for Whisper - only allow English or Urdu
+                whisper_language = None
+                if language == "urdu":
+                    whisper_language = "urdu"
+                elif language == "english":
+                    whisper_language = "english"
+                # For "auto", let Whisper detect but we'll filter later
+                
+                result = model.transcribe(temp_audio_path, language=whisper_language)
+                
+                # Apply strict language detection
+                detected_language = self._strict_detect_language_from_text(result["text"])
+                
+                return {
+                    "text": result["text"].strip(),
+                    "language": detected_language,
+                    "service": "local_whisper",
+                    "confidence": 0.8
+                }
+            finally:
+                if os.path.exists(temp_audio_path):
+                    os.unlink(temp_audio_path)
+                    
+        except ImportError:
+            logger.warning("Whisper not available for local STT")
+            return None
+        except Exception as e:
+            logger.warning(f"Local Whisper STT failed: {e}")
+            return None
+    
+    async def _try_speech_recognition(self, audio_content: bytes) -> Optional[Dict[str, Any]]:
+        """Try SpeechRecognition with Google Web API (mainly English)"""
+        try:
+            import speech_recognition as sr
+            from pydub import AudioSegment
+            import io
+            
+            # Convert webm to wav for SpeechRecognition
+            audio = AudioSegment.from_file(io.BytesIO(audio_content), format="webm")
+            wav_data = io.BytesIO()
+            audio.export(wav_data, format="wav")
+            wav_data.seek(0)
+            
+            recognizer = sr.Recognizer()
+            
+            with sr.AudioFile(wav_data) as source:
+                audio_data = recognizer.record(source)
+                text = recognizer.recognize_google(audio_data)
+                
+                # Apply strict language detection
+                detected_language = self._strict_detect_language_from_text(text)
+                
+                return {
+                    "text": text,
+                    "language": detected_language,
+                    "service": "google_web_api",
+                    "confidence": 0.7
+                }
+                
+        except ImportError:
+            logger.warning("SpeechRecognition not available")
+            return None
+        except Exception as e:
+            logger.warning(f"SpeechRecognition failed: {e}")
+            return None
+    
+    def _strict_detect_language_from_text(self, text: str) -> str:
+        """
+        Strict language detection that only identifies Urdu or English
+        Specifically excludes Hindi, Arabic, and other languages
+        """
+        try:
+            text = text.strip()
+            if not text:
+                return "english"  # Default to English for empty text
+            
+            # === STRICT URDU DETECTION ===
+            # Urdu-specific character ranges (excluding Arabic and Hindi overlaps)
+            urdu_specific_ranges = [
+                r'[\u0679-\u0679]',  # Urdu-specific letters
+                r'[\u067E-\u067E]',  # Peh
+                r'[\u0686-\u0686]',  # Cheh
+                r'[\u0688-\u0688]',  # Ddal
+                r'[\u0691-\u0691]',  # Rreh
+                r'[\u0698-\u0698]',  # Jeh
+                r'[\u06A9-\u06A9]',  # Keheh
+                r'[\u06AF-\u06AF]',  # Gaf
+                r'[\u06BA-\u06BA]',  # Noon Ghunna
+                r'[\u06BE-\u06BE]',  # Heh Doachashmee
+                r'[\u06C1-\u06C1]',  # Heh Goal
+                r'[\u06C2-\u06C2]',  # Heh Goal with Hamza Above
+                r'[\u06CC-\u06CC]',  # Farsi Yeh
+                r'[\u06D2-\u06D2]',  # Yeh Barree
+            ]
+            
+            # Common Urdu words that are distinct from Hindi/Arabic
+            urdu_specific_words = [
+                'ہے', 'ہیں', 'ہوں', 'کیا', 'کے', 'کو', 'سے', 'پر', 'میں', 
+                'اور', 'لیکن', 'اگر', 'تو', 'بھی', 'ہی', 'تھا', 'تھی', 
+                'تھے', 'ہو', 'رہا', 'رہی', 'رہے', 'دیں', 'دی', 'دو', 'دیجیے',
+                'برائے', 'کےلیے', 'کےساتھ', 'کےبعد', 'کےپاس', 'کےنیچے'
+            ]
+            
+            # Check for Urdu-specific characters
+            urdu_char_count = 0
+            for pattern in urdu_specific_ranges:
+                urdu_char_count += len(re.findall(pattern, text))
+            
+            # Check for Urdu-specific words
+            urdu_word_count = sum(1 for word in urdu_specific_words if word in text)
+            
+            # Check for common Urdu sentence structures
+            urdu_indicators = [
+                ' کا ', ' کی ', ' کے ', ' کو ', ' سے ', ' پر ', ' میں ', ' نے ',
+                ' ہی ', ' بھی ', ' تو ', ' اگر ', ' لیکن ', ' اور ', ' یا '
+            ]
+            urdu_structure_count = sum(1 for indicator in urdu_indicators if indicator in text)
+            
+            # === HINDI EXCLUSION ===
+            # Hindi-specific characters and words to exclude
+            hindi_specific_chars = r'[\u0900-\u097F]'  # Devanagari range
+            hindi_char_count = len(re.findall(hindi_specific_chars, text))
+            
+            hindi_specific_words = ['है', 'हो', 'की', 'के', 'को', 'से', 'में', 'ना', 'नी', 'ने']
+            hindi_word_count = sum(1 for word in hindi_specific_words if word in text)
+            
+            # === ARABIC EXCLUSION ===
+            # Arabic-specific characters (excluding common Urdu-Arabic overlaps)
+            arabic_specific_chars = r'[\uFE70-\uFEFF]'  # Arabic presentation forms
+            arabic_char_count = len(re.findall(arabic_specific_chars, text))
+            
+            # === ENGLISH DETECTION ===
+            english_words = [
+                'the', 'and', 'you', 'that', 'was', 'for', 'are', 'with', 'his', 'they',
+                'this', 'have', 'from', 'one', 'had', 'word', 'but', 'not', 'what', 'all',
+                'were', 'when', 'your', 'can', 'said', 'there', 'each', 'which', 'she', 'do',
+                'how', 'their', 'will', 'other', 'about', 'out', 'many', 'then', 'them', 'these'
+            ]
+            text_lower = text.lower()
+            english_score = sum(1 for word in english_words if word in text_lower)
+            
+            # === LANGUAGE DECISION LOGIC ===
+            
+            # First, exclude Hindi and Arabic
+            if hindi_char_count > 2 or hindi_word_count > 1:
+                logger.info("🔍 Hindi detected, treating as English")
+                return "english"
+            
+            if arabic_char_count > 2:
+                logger.info("🔍 Arabic detected, treating as English")
+                return "english"
+            
+            # Then detect Urdu with high confidence
+            urdu_confidence_score = (
+                urdu_char_count * 2 + 
+                urdu_word_count * 3 + 
+                urdu_structure_count * 1.5
+            )
+            
+            # Strong Urdu detection thresholds
+            if urdu_confidence_score >= 5:
+                logger.info(f"🔍 Urdu detected (confidence: {urdu_confidence_score})")
+                return "urdu"
+            
+            # English detection
+            if english_score >= 3 or len(text.split()) >= 4:
+                logger.info(f"🔍 English detected (score: {english_score})")
+                return "english"
+            
+            # If we have some Urdu indicators but not enough for confident detection
+            if urdu_confidence_score >= 2:
+                logger.info(f"🔍 Weak Urdu signals, treating as Urdu (confidence: {urdu_confidence_score})")
+                return "urdu"
+            
+            # Default to English
+            logger.info("🔍 Defaulting to English")
+            return "english"
+            
+        except Exception as e:
+            logger.error(f"❌ Language detection error: {e}")
+            return "english"  # Safe default
+    
+    def _detect_language_from_text(self, text: str) -> str:
+        """Legacy method for backward compatibility"""
+        return self._strict_detect_language_from_text(text)
+    
+    async def text_to_speech(self, text: str, language: str = "english") -> Optional[Dict[str, Any]]:
+        """
+        Convert text to speech using FREE TTS services
+        NOTE: Keeping TTS for potential future use, but currently disabled for responses
+        """
+        try:
+            # Since we're only returning text responses now, TTS is optional
+            # But keeping the function for potential future use
+            logger.info(f"🔊 TTS requested for {language}: {text[:50]}...")
+            return None  # Disable TTS for now
+            
+        except Exception as e:
+            logger.error(f"❌ TTS Error: {e}")
+            return None
+
+    async def cleanup_old_audio_files(self, max_age_hours: int = 1):
+        """Clean up audio files older than specified hours"""
+        try:
+            audio_dir = os.path.join("static", "audio")
+            if not os.path.exists(audio_dir):
+                return
+                
+            current_time = time.time()
+            deleted_count = 0
+            
+            for filename in os.listdir(audio_dir):
+                if filename.startswith("tts_") and (filename.endswith(".mp3") or filename.endswith(".wav")):
+                    file_path = os.path.join(audio_dir, filename)
+                    if os.path.isfile(file_path):
+                        # Delete files older than max_age_hours
+                        file_age_hours = (current_time - os.path.getctime(file_path)) / 3600
+                        if file_age_hours > max_age_hours:
+                            os.remove(file_path)
+                            deleted_count += 1
+                            logger.info(f"🧹 Cleaned up old audio file: {filename}")
+            
+            if deleted_count > 0:
+                logger.info(f"🧹 Cleaned up {deleted_count} old audio file(s)")
+                
+        except Exception as e:
+            logger.error(f"Error cleaning up audio files: {e}")
+
+# Global audio processor instance
+audio_processor = AudioProcessor()

config.json

@@ -0,0 +1,13 @@
+{
+    "model_provider": "openrouter",
+    "model_id": "deepseek/deepseek-r1:free",
+    "api_keys_folder": "config",
+    "index_path": "cancer_index_store",
+    "dataset_path": "DataSet/breast_cancer.json",  
+    "similarity_top_k": 5,
+    "temperature": 0.7,
+    "max_tokens": 1024,
+    "combine_sources": true,
+    "fallback_message": "Sorry, I don't know the answer.",
+    "strict_breast_cancer_only": true
+}

index.html

@@ -0,0 +1,161 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Well Being Agent - Breast Cancer Support</title>
+    
+    <!-- Optimized Urdu Fonts -->
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Noto+Nastaliq+Urdu:wght@400;500;600;700&family=Noto+Naskh+Arabic:wght@400;500;600;700&family=Scheherazade+New:wght@400;500;600;700&family=Lateef:wght@400;500;600;700&family=Amiri:wght@400;500;600;700&family=Poppins:wght@300;400;500;600;700&family=Playfair+Display:wght@400;500;600&display=swap" rel="stylesheet">
+    
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <link rel="stylesheet" href="styles.css">
+</head>
+<body>
+    <!-- Animated Background Elements -->
+    <div class="floating-elements">
+        <div class="floating-element el-1"></div>
+        <div class="floating-element el-2"></div>
+        <div class="floating-element el-3"></div>
+        <div class="floating-element el-4"></div>
+    </div>
+
+    <div class="container">
+        <!-- Header Section -->
+        <header class="header">
+            <div class="header-content">
+                <div class="logo-container">
+                    <div class="logo">
+                        <i class="fas fa-heartbeat"></i>
+                    </div>
+                    <h1 class="title">Well Being Agent</h1>
+                </div>
+                <p class="subtitle">Breast Cancer Support System</p>
+                <p class="compassion-message">Providing compassionate, evidence-based support for breast cancer patients and their families</p>
+            </div>
+        </header>
+
+        <!-- Main Content -->
+        <main class="main-content">
+            <!-- Quick Questions Section -->
+            <aside class="quick-questions">
+                <div class="section-header">
+                    <h2 class="section-title">Quick Questions</h2>
+                    <div class="decoration-line"></div>
+                </div>
+                
+                <!-- Tab Navigation -->
+                <div class="tabs-container">
+                    <div class="tabs">
+                        <button class="tab-btn active" data-tab="english">
+                            <i class="fas fa-language"></i> English Questions
+                        </button>
+                        <button class="tab-btn" data-tab="urdu">
+                            <i class="fas fa-language"></i> اردو سوالات
+                        </button>
+                    </div>
+                    
+                    <!-- English Questions Tab -->
+                    <div class="tab-content active" id="english-tab">
+                        <div class="questions-grid" id="english-questions">
+                            <!-- Recent English questions will appear here dynamically -->
+                            <div class="empty-state">
+                                <i class="fas fa-comments"></i>
+                                <p>No recent English questions yet. Start chatting to see them here!</p>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <!-- Urdu Questions Tab -->
+                    <div class="tab-content" id="urdu-tab">
+                        <div class="questions-grid urdu-questions" id="urdu-questions">
+                            <!-- Recent Urdu questions will appear here dynamically -->
+                            <div class="empty-state">
+                                <i class="fas fa-comments"></i>
+                                <p>ابھی تک کوئی اردو سوالات نہیں ہیں۔ بات چیت شروع کریں!</p>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </aside>
+
+            <!-- Chat Section -->
+            <section class="chat-section">
+                <div class="chat-container">
+                    <!-- Chat Header -->
+                    <div class="chat-header">
+                        <div class="chat-profile">
+                            <div class="profile-avatar">
+                                <i class="fas fa-robot"></i>
+                                <div class="online-indicator"></div>
+                            </div>
+                            <div class="profile-info">
+                                <h3>Well Being Assistant</h3>
+                                <p>Always here to support you</p>
+                            </div>
+                        </div>
+                        <div class="chat-stats">
+                            <div class="stat">
+                                <span class="stat-number" id="messageCount">0</span>
+                                <span class="stat-label">Messages</span>
+                            </div>
+                            <div class="stat">
+                                <span class="stat-number" id="activeLanguage">English</span>
+                                <span class="stat-label">Language</span>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Chat Messages -->
+                    <div class="chat-messages" id="chatMessages">
+                        <div class="message system-message">
+                            <div class="message-avatar">
+                                <i class="fas fa-robot"></i>
+                            </div>
+                            <div class="message-content">
+                                <p>Hello! I'm your Well Being Agent. I'm here to provide supportive, evidence-based information about breast cancer. How can I help you today?</p>
+                                <span class="message-time" id="welcomeTime"></span>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Typing Indicator -->
+                    <div class="typing-indicator" id="typingIndicator">
+                        <div class="typing-dots">
+                            <span></span>
+                            <span></span>
+                            <span></span>
+                        </div>
+                        <p>Thinking of the best way to help you...</p>
+                    </div>
+
+                    <!-- Chat Input -->
+                    <div class="chat-input-container">
+                        <div class="input-wrapper">
+                            <input type="text" id="userInput" placeholder="Ask about breast cancer support, treatment options, or recovery...">
+                        
+                            <!-- 🎤 New voice recording button -->
+                            <button id="voiceButton" class="voice-button">
+                            <i class="fas fa-microphone"></i>
+                            </button>
+                            <!-- ✉️ Existing send button -->
+                            <button id="sendButton" class="send-button">
+                            <i class="fas fa-paper-plane"></i>
+                            <span class="button-text">Send</span>
+                            </button>
+                        </div>
+                    <div class="input-hint">
+                        <i class="fas fa-lightbulb"></i>
+                        <span>Current language: <strong id="currentLanguageDisplay">English</strong> - You can ask about symptoms, treatments, recovery, or emotional support</span>
+                    </div>
+                    </div>
+                </div>
+            </section>
+        </main>
+    </div>
+
+    <script src="script.js"></script>
+</body>
+</html>

language_utils.py

@@ -0,0 +1,28 @@
+# language_utils.py
+import re
+from langdetect import detect, LangDetectError
+
+def detect_query_language(text: str) -> str:
+    """
+    Detect if text is English or Urdu
+    Returns: 'english' or 'urdu'
+    """
+    try:
+        # First check for Urdu characters (more reliable)
+        urdu_pattern = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]+')
+        if urdu_pattern.search(text):
+            return 'urdu'
+        
+        # Then use langdetect for other cases
+        detected_lang = detect(text)
+        return 'urdu' if detected_lang == 'ur' else 'english'
+        
+    except LangDetectError:
+        return 'english'
+    except Exception:
+        return 'english'
+
+def is_urdu_text(text: str) -> bool:
+    """Check if text contains Urdu characters"""
+    urdu_pattern = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]+')
+    return bool(urdu_pattern.search(text))

rag_system.log

@@ -0,0 +1,18 @@
+2025-11-10 22:28:46,853 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-10 22:30:05,985 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-10 22:49:31,018 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-10 23:05:34,645 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-11 17:57:12,543 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-11 19:35:15,603 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-11 19:35:28,651 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-11 21:33:02,584 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-11 23:10:45,825 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-11 23:33:40,189 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-12 00:13:26,990 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-12 18:01:31,774 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-12 18:43:39,916 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-12 19:08:33,936 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-12 19:24:28,082 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-12 20:50:23,292 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-12 20:58:54,128 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-11-12 22:19:25,719 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2

requirements.txt

@@ -0,0 +1,22 @@
+fastapi
+uvicorn
+python-dotenv
+requests
+pydantic
+langdetect
+torch
+transformers
+sentence-transformers
+llama-index-core
+llama-index-embeddings-huggingface
+gtts
+pyttsx3
+SpeechRecognition
+pydub
+openai-whisper
+python-multipart
+python-dateutil
+huggingface_hub
+openai
+numpy
+pillow

script.js

@@ -0,0 +1,463 @@
+// script.js - Voice queries now return text responses only
+// DOM Elements
+const chatMessages = document.getElementById('chatMessages');
+const userInput = document.getElementById('userInput');
+const sendButton = document.getElementById('sendButton');
+const voiceButton = document.getElementById('voiceButton');
+const typingIndicator = document.getElementById('typingIndicator');
+const messageCount = document.getElementById('messageCount');
+const activeLanguage = document.getElementById('activeLanguage');
+const currentLanguageDisplay = document.getElementById('currentLanguageDisplay');
+const welcomeTime = document.getElementById('welcomeTime');
+const englishQuestions = document.getElementById('english-questions');
+const urduQuestions = document.getElementById('urdu-questions');
+
+// State Management
+let currentLanguage = 'english';
+let messageCounter = 0;
+let mediaRecorder;
+let audioChunks = [];
+let isRecording = false;
+
+// Initialize
+document.addEventListener('DOMContentLoaded', function() {
+    initializeApp();
+    setupEventListeners();
+    setWelcomeTime();
+    initializeWelcomeMessage();
+});
+
+async function initializeApp() {
+    updateLanguageDisplay();
+    updateInputPlaceholder();
+    await loadPredefinedQuestions();
+    updateQuestionsDisplay();
+}
+
+function setupEventListeners() {
+    // Send message on button click
+    sendButton.addEventListener('click', sendMessage);
+    
+    // Send message on Enter key
+    userInput.addEventListener('keypress', function(e) {
+        if (e.key === 'Enter') {
+            sendMessage();
+        }
+    });
+
+    // Tab switching
+    document.querySelectorAll('.tab-btn').forEach(btn => {
+        btn.addEventListener('click', function() {
+            const tabId = this.getAttribute('data-tab');
+            switchTab(tabId);
+        });
+    });
+
+    // Voice button listener
+    if (voiceButton) {
+        voiceButton.addEventListener('click', async () => {
+            if (!isRecording) {
+                startRecording();
+            } else {
+                stopRecording();
+            }
+        });
+    }
+
+    userInput.focus();
+}
+
+function initializeWelcomeMessage() {
+    // Ensure the welcome message has proper styling and is visible
+    const welcomeMessage = document.querySelector('.system-message');
+    if (welcomeMessage) {
+        welcomeMessage.style.opacity = '1';
+        welcomeMessage.style.transform = 'translateY(0) scale(1)';
+    }
+}
+
+function setWelcomeTime() {
+    const now = new Date();
+    welcomeTime.textContent = now.toLocaleTimeString([], { 
+        hour: '2-digit', 
+        minute: '2-digit' 
+    });
+}
+
+function switchTab(tabId) {
+    document.querySelectorAll('.tab-btn').forEach(btn => btn.classList.remove('active'));
+    document.querySelector(`[data-tab="${tabId}"]`).classList.add('active');
+
+    document.querySelectorAll('.tab-content').forEach(content => content.classList.remove('active'));
+    document.getElementById(`${tabId}-tab`).classList.add('active');
+
+    const newLanguage = tabId === 'urdu' ? 'urdu' : 'english';
+    if (currentLanguage !== newLanguage) {
+        currentLanguage = newLanguage;
+        updateLanguageDisplay();
+        updateInputPlaceholder();
+    }
+}
+
+function updateLanguageDisplay() {
+    activeLanguage.textContent = currentLanguage === 'urdu' ? 'اردو' : 'English';
+    currentLanguageDisplay.textContent = currentLanguage === 'urdu' ? 'Urdu' : 'English';
+}
+
+function updateInputPlaceholder() {
+    if (currentLanguage === 'urdu') {
+        userInput.placeholder = 'بریسٹ کینسر کے بارے میں پوچھیں...';
+        userInput.style.direction = 'rtl';
+        userInput.style.textAlign = 'right';
+    } else {
+        userInput.placeholder = 'Ask about breast cancer support, treatment options, or recovery...';
+        userInput.style.direction = 'ltr';
+        userInput.style.textAlign = 'left';
+    }
+}
+
+async function loadPredefinedQuestions() {
+    try {
+        const englishResponse = await fetch('/predefined-questions?language=english');
+        const englishData = await englishResponse.json();
+        if (englishData.status === 'success') {
+            window.predefinedEnglishQuestions = englishData.questions;
+        }
+
+        const urduResponse = await fetch('/predefined-questions?language=urdu');
+        const urduData = await urduResponse.json();
+        if (urduData.status === 'success') {
+            window.predefinedUrduQuestions = urduData.questions;
+        }
+    } catch (error) {
+        console.error('Error loading predefined questions:', error);
+    }
+}
+
+function updateQuestionsDisplay() {
+    updateQuestionList(englishQuestions, 'english');
+    updateQuestionList(urduQuestions, 'urdu');
+}
+
+function updateQuestionList(container, language) {
+    container.innerHTML = '';
+    const predefinedQuestions = language === 'urdu' ? 
+        window.predefinedUrduQuestions : 
+        window.predefinedEnglishQuestions;
+    
+    if (predefinedQuestions && predefinedQuestions.length > 0) {
+        predefinedQuestions.forEach((questionData) => {
+            const questionCard = createQuestionCard(questionData, language);
+            container.appendChild(questionCard);
+        });
+    } else {
+        const emptyState = document.createElement('div');
+        emptyState.className = 'empty-state';
+        emptyState.innerHTML = `
+            <i class="fas fa-comments"></i>
+            <p>${language === 'urdu' ? 'ابھی تک کوئی اردو سوالات نہیں ہیں۔' : 'No questions available yet.'}</p>
+        `;
+        container.appendChild(emptyState);
+    }
+}
+
+function createQuestionCard(questionData, language) {
+    const questionCard = document.createElement('button');
+    questionCard.className = `question-card ${language === 'urdu' ? 'urdu-text' : ''} predefined-card`;
+    questionCard.setAttribute('data-question', questionData.question);
+    const icon = questionData.icon || 'fas fa-question-circle';
+    questionCard.innerHTML = `
+        <div class="card-icon ${questionData.category || 'general'}">
+            <i class="${icon}"></i>
+        </div>
+        <div class="card-content">
+            <h3>${questionData.question}</h3>
+        </div>
+        <div class="card-arrow">
+            <i class="fas fa-chevron-right"></i>
+        </div>
+    `;
+    questionCard.addEventListener('click', function() {
+        userInput.value = questionData.question;
+        sendMessage();
+    });
+    return questionCard;
+}
+
+async function sendMessage() {
+    const message = userInput.value.trim();
+    if (!message) return;
+    
+    addMessageToChat(message, 'user', currentLanguage);
+    userInput.value = '';
+    userInput.disabled = true;
+    sendButton.disabled = true;
+    showTypingIndicator();
+
+    try {
+        const response = await fetch('/ask-query', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ query: message, language: currentLanguage, response_type: 'text' })
+        });
+        const data = await response.json();
+        hideTypingIndicator();
+
+        if (data.status === 'success') {
+            addMessageToChat(data.answer, 'system', data.language);
+            updateMessageCount();
+        } else {
+            addMessageToChat("I'm having trouble processing your request. Please try again.", 'system', 'english');
+        }
+    } catch (error) {
+        console.error('Error:', error);
+        hideTypingIndicator();
+        addMessageToChat("Connection issue. Please try again.", 'system', 'english');
+    } finally {
+        userInput.disabled = false;
+        sendButton.disabled = false;
+        userInput.focus();
+    }
+}
+
+function cleanUrduText(text) {
+    const urduFixes = {
+        // Character fixes
+        'ہےہ': 'ہے',
+        'مہےں': 'میں', 
+        'ہےں': 'ہیں',
+        'ھے': 'ہے',
+        'ھوں': 'ہوں',
+        'ھیں': 'ہیں',
+        'ےے': 'ے',
+        'ںں': 'ں',
+        'ہہ': 'ہ',
+        'یی': 'ی',
+        
+        // Word fixes
+        'مجہے': 'مجھے',
+        'پروگرہوں': 'پروگرام',
+        'کہےنسر': 'کینسر',
+        'ڈڈاکٹر': 'ڈاکٹر',
+        'کا ے لہےے': 'کے لیے',
+        'جسے سے': 'جس سے',
+        'اکٹر': 'ڈاکٹر',
+        'اکیل': 'اکیلے',
+        'میش': 'میں',
+        'وتی': 'ہوتی',
+        'لکی': 'ہلکی',
+        'بتر': 'بہتر',
+        
+        // Grammar fixes
+        'ک دوران': 'کے دوران',
+        'ک بار': 'کے بارے',
+        'ک بعد': 'کے بعد', 
+        'ک لی': 'کے لیے',
+        'ک ساتھ': 'کے ساتھ',
+        'ک طور': 'کے طور',
+        'ک ذریع': 'کے ذریعے',
+        'ک مطابق': 'کے مطابق'
+    };
+
+    let cleanedText = text;
+    
+    // Apply all fixes
+    Object.keys(urduFixes).forEach(wrong => {
+        const regex = new RegExp(escapeRegExp(wrong), 'g');
+        cleanedText = cleanedText.replace(regex, urduFixes[wrong]);
+    });
+
+    // Fix spacing issues
+    cleanedText = cleanedText.replace(/\s+/g, ' ');
+    cleanedText = cleanedText.replace(/ \./g, '.');
+    cleanedText = cleanedText.replace(/ ،/g, '،');
+    cleanedText = cleanedText.replace(/  /g, ' ');
+    cleanedText = cleanedText.replace(/۔۔/g, '۔');
+    
+    return cleanedText.trim();
+}
+
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function addMessageToChat(message, sender, language = 'english') {
+    // Clean Urdu text before displaying
+    if (language === 'urdu') {
+        message = cleanUrduText(message);
+    }
+    
+    const messageDiv = document.createElement('div');
+    messageDiv.className = `message ${sender}-message`;
+    if (language === 'urdu') {
+        messageDiv.classList.add('urdu-text');
+    }
+    
+    const timestamp = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    const avatarIcon = sender === 'user' ? 'fas fa-user' : 'fas fa-robot';
+    
+    messageDiv.innerHTML = `
+        <div class="message-avatar">
+            <i class="${avatarIcon}"></i>
+        </div>
+        <div class="message-content ${language === 'urdu' ? 'urdu-text' : ''}">
+            <p>${formatMessage(message)}</p>
+            <span class="message-time">${timestamp}</span>
+            ${language === 'urdu' ? '<div class="language-badge">اردو</div>' : ''}
+        </div>
+    `;
+    
+    chatMessages.appendChild(messageDiv);
+    scrollToBottom();
+    
+    // Apply animation to new messages only
+    setTimeout(() => {
+        messageDiv.style.opacity = '1';
+        messageDiv.style.transform = 'translateY(0) scale(1)';
+    }, 10);
+}
+
+function formatMessage(message) {
+    return message.replace(/\n/g, '<br>');
+}
+
+function showTypingIndicator() {
+    typingIndicator.style.display = 'flex';
+    scrollToBottom();
+}
+
+function hideTypingIndicator() {
+    typingIndicator.style.display = 'none';
+}
+
+function updateMessageCount() {
+    messageCounter++;
+    messageCount.textContent = messageCounter;
+}
+
+function scrollToBottom() {
+    setTimeout(() => {
+        chatMessages.scrollTo({ top: chatMessages.scrollHeight, behavior: 'smooth' });
+    }, 100);
+}
+
+// Voice Recording Feature - Now returns text responses only
+async function startRecording() {
+    try {
+        const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        mediaRecorder = new MediaRecorder(stream);
+        audioChunks = [];
+
+        mediaRecorder.ondataavailable = e => audioChunks.push(e.data);
+        mediaRecorder.onstop = async () => {
+            const audioBlob = new Blob(audioChunks, { type: 'audio/webm' });
+            const formData = new FormData();
+            formData.append('file', audioBlob, 'voiceNote.webm');
+            formData.append('language', currentLanguage); // Pass current tab language
+
+            // Add user voice message to chat
+            addUserVoiceMessageToChat(audioBlob);
+            showTypingIndicator();
+
+            try {
+                const response = await fetch('/voice-query', {
+                    method: 'POST',
+                    body: formData
+                });
+                const data = await response.json();
+                hideTypingIndicator();
+
+                if (data.status === 'success') {
+                    // ✅ ALWAYS show text response for voice queries
+                    if (data.text && data.text.trim() !== '') {
+                        addMessageToChat(data.text, 'system', data.language);
+                    } else {
+                        // Fallback message
+                        const fallbackMessage = data.language === 'urdu' 
+                            ? "میں آپ کی آواز کا پیغام سمجھ گئی ہوں۔ آپ کیسے مدد کر سکتی ہوں؟"
+                            : "I've processed your voice message. How can I help you further?";
+                        addMessageToChat(fallbackMessage, 'system', data.language);
+                    }
+                    
+                    updateMessageCount();
+                } else {
+                    const errorMessage = currentLanguage === 'urdu'
+                        ? "معذرت، آپ کی آواز کا پیغام پروسیس نہیں کر سکی۔"
+                        : "Sorry, couldn't process your voice message.";
+                    addMessageToChat(errorMessage, 'system', currentLanguage);
+                }
+            } catch (err) {
+                console.error('Voice query error:', err);
+                hideTypingIndicator();
+                const errorMessage = currentLanguage === 'urdu'
+                    ? "آواز کے پروسیس میں خرابی۔"
+                    : "Error processing voice input.";
+                addMessageToChat(errorMessage, 'system', currentLanguage);
+            }
+        };
+
+        mediaRecorder.start();
+        isRecording = true;
+        voiceButton.classList.add('recording');
+        voiceButton.innerHTML = '<i class="fas fa-stop"></i>';
+    } catch (err) {
+        console.error('Microphone access error:', err);
+        const errorMessage = currentLanguage === 'urdu'
+            ? 'براہ کرم آواز ریکارڈ کرنے کے لیے مائیکروفون کی رسائی کی اجازت دیں۔'
+            : 'Please allow microphone access to record voice messages.';
+        alert(errorMessage);
+    }
+}
+
+function addUserVoiceMessageToChat(audioBlob) {
+    const messageDiv = document.createElement('div');
+    messageDiv.className = `message user-message audio-message`;
+    
+    const timestamp = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    const audioUrl = URL.createObjectURL(audioBlob);
+    
+    messageDiv.innerHTML = `
+        <div class="message-avatar">
+            <i class="fas fa-user"></i>
+        </div>
+        <div class="message-content">
+            <div class="audio-message-container user-audio">
+                <div class="audio-player-wrapper">
+                    <audio controls class="voice-note-player">
+                        <source src="${audioUrl}" type="audio/webm">
+                        Your browser does not support the audio element.
+                    </audio>
+                </div>
+                <div class="audio-duration">Your voice message</div>
+            </div>
+            <span class="message-time">${timestamp}</span>
+        </div>
+    `;
+    
+    chatMessages.appendChild(messageDiv);
+    scrollToBottom();
+    
+    setTimeout(() => {
+        messageDiv.style.opacity = '1';
+        messageDiv.style.transform = 'translateY(0) scale(1)';
+    }, 10);
+}
+
+function stopRecording() {
+    if (mediaRecorder && mediaRecorder.state !== 'inactive') {
+        mediaRecorder.stop();
+    }
+    isRecording = false;
+    voiceButton.classList.remove('recording');
+    voiceButton.innerHTML = '<i class="fas fa-microphone"></i>';
+}
+
+// Logo animation
+const logo = document.querySelector('.logo');
+if (logo) {
+    setInterval(() => {
+        logo.style.transform = 'rotate(5deg)';
+        setTimeout(() => { logo.style.transform = 'rotate(-5deg)'; }, 1000);
+        setTimeout(() => { logo.style.transform = 'rotate(0deg)'; }, 2000);
+    }, 5000);
+}

styles.css

@@ -0,0 +1,1344 @@
+:root {
+    --primary-pink: #ff6b93;
+    --primary-pink-light: #ff8fa9;
+    --primary-pink-lighter: #ffb6c8;
+    --primary-pink-lightest: #ffe8ee;
+    --secondary-pink: #f8c9d4;
+    --accent-pink: #ff4d7a;
+    --white: #ffffff;
+    --white-soft: #fefefe;
+    --white-softer: #fafafa;
+    --gray-light: #f5f5f5;
+    --gray-medium: #e0e0e0;
+    --gray-dark: #666666;
+    --text-dark: #333333;
+    --text-secondary: #666666;
+    --shadow-soft: 0 8px 32px rgba(255, 107, 147, 0.1);
+    --shadow-medium: 0 15px 35px rgba(255, 107, 147, 0.15);
+    --shadow-strong: 0 20px 50px rgba(255, 107, 147, 0.2);
+    --border-radius: 24px;
+    --border-radius-small: 16px;
+    --transition: all 0.4s cubic-bezier(0.175, 0.885, 0.32, 1.1);
+    --transition-fast: all 0.2s ease;
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Poppins', sans-serif;
+    background: linear-gradient(135deg, #fff5f7 0%, #ffffff 100%);
+    color: var(--text-dark);
+    min-height: 100vh;
+    overflow-x: hidden;
+    position: relative;
+}
+
+.floating-elements {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    z-index: -1;
+    overflow: hidden;
+}
+
+.floating-element {
+    position: absolute;
+    border-radius: 50%;
+    background: linear-gradient(135deg, var(--primary-pink-lightest), var(--primary-pink-lighter));
+    opacity: 0.4;
+    animation: float 20s infinite linear;
+}
+
+.floating-element.el-1 {
+    width: 200px;
+    height: 200px;
+    top: 10%;
+    left: 5%;
+    animation-duration: 25s;
+}
+
+.floating-element.el-2 {
+    width: 150px;
+    height: 150px;
+    top: 60%;
+    right: 10%;
+    animation-duration: 20s;
+    animation-direction: reverse;
+}
+
+.floating-element.el-3 {
+    width: 100px;
+    height: 100px;
+    bottom: 20%;
+    left: 15%;
+    animation-duration: 30s;
+}
+
+.floating-element.el-4 {
+    width: 120px;
+    height: 120px;
+    top: 20%;
+    right: 20%;
+    animation-duration: 35s;
+    animation-direction: reverse;
+}
+
+@keyframes float {
+    0% {
+        transform: translateY(0) rotate(0deg);
+    }
+    33% {
+        transform: translateY(-30px) rotate(120deg);
+    }
+    66% {
+        transform: translateY(20px) rotate(240deg);
+    }
+    100% {
+        transform: translateY(0) rotate(360deg);
+    }
+}
+
+.container {
+    max-width: 1400px;
+    margin: 0 auto;
+    padding: 2rem;
+    width: 100%;
+}
+
+.header {
+    text-align: center;
+    margin-bottom: 3rem;
+    animation: fadeInUp 1s ease-out;
+}
+
+.header-content {
+    max-width: 800px;
+    margin: 0 auto;
+    width: 100%;
+}
+
+.logo-container {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 1rem;
+    margin-bottom: 1rem;
+    flex-wrap: wrap;
+}
+
+.logo {
+    width: 70px;
+    height: 70px;
+    background: linear-gradient(135deg, var(--primary-pink), var(--accent-pink));
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 2rem;
+    color: var(--white);
+    box-shadow: var(--shadow-strong);
+    animation: pulse 2s infinite;
+    flex-shrink: 0;
+}
+
+@keyframes pulse {
+    0% {
+        transform: scale(1);
+        box-shadow: var(--shadow-strong);
+    }
+    50% {
+        transform: scale(1.05);
+        box-shadow: 0 0 30px rgba(255, 107, 147, 0.4);
+    }
+    100% {
+        transform: scale(1);
+        box-shadow: var(--shadow-strong);
+    }
+}
+
+.title {
+    font-family: 'Playfair Display', serif;
+    font-size: clamp(2.5rem, 5vw, 3.5rem);
+    font-weight: 600;
+    background: linear-gradient(135deg, var(--primary-pink), var(--accent-pink));
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    margin-bottom: 0.5rem;
+    line-height: 1.2;
+}
+
+.subtitle {
+    font-size: clamp(1.1rem, 2.5vw, 1.4rem);
+    color: var(--text-secondary);
+    margin-bottom: 1rem;
+    font-weight: 400;
+}
+
+.compassion-message {
+    font-size: clamp(0.9rem, 2vw, 1.1rem);
+    color: var(--text-secondary);
+    line-height: 1.6;
+    max-width: 600px;
+    margin: 0 auto;
+}
+
+.main-content {
+    display: grid;
+    grid-template-columns: 1fr 1.5fr;
+    gap: 2.5rem;
+    animation: fadeInUp 1s ease-out 0.3s both;
+    width: 100%;
+}
+
+@keyframes fadeInUp {
+    from {
+        opacity: 0;
+        transform: translateY(30px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.quick-questions {
+    animation: slideInLeft 1s ease-out 0.5s both;
+    width: 100%;
+}
+
+@keyframes slideInLeft {
+    from {
+        opacity: 0;
+        transform: translateX(-30px);
+    }
+    to {
+        opacity: 1;
+        transform: translateX(0);
+    }
+}
+
+.section-header {
+    margin-bottom: 2rem;
+}
+
+.section-title {
+    font-family: 'Playfair Display', serif;
+    font-size: clamp(1.5rem, 3vw, 1.8rem);
+    font-weight: 600;
+    color: var(--text-dark);
+    margin-bottom: 0.5rem;
+}
+
+.decoration-line {
+    width: 60px;
+    height: 4px;
+    background: linear-gradient(to right, var(--primary-pink), var(--accent-pink));
+    border-radius: 2px;
+}
+
+.tabs-container {
+    margin-top: 1rem;
+    width: 100%;
+}
+
+.tabs {
+    display: flex;
+    background: var(--white);
+    border-radius: 12px;
+    padding: 0.5rem;
+    margin-bottom: 1.5rem;
+    box-shadow: var(--shadow-soft);
+    width: 100%;
+}
+
+.tab-btn {
+    flex: 1;
+    padding: 0.75rem 1rem;
+    border: none;
+    background: transparent;
+    color: var(--text-secondary);
+    border-radius: 8px;
+    cursor: pointer;
+    transition: var(--transition);
+    font-weight: 500;
+    font-size: clamp(0.8rem, 1.5vw, 0.9rem);
+    min-width: 0;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.tab-btn.active {
+    background: linear-gradient(135deg, var(--primary-pink), var(--accent-pink));
+    color: var(--white);
+    box-shadow: var(--shadow-soft);
+}
+
+.tab-btn:hover:not(.active) {
+    background: var(--primary-pink-lightest);
+    color: var(--primary-pink);
+}
+
+.tab-content {
+    display: none;
+}
+
+.tab-content.active {
+    display: block;
+    animation: fadeIn 0.5s ease-in-out;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(10px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.questions-grid {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+    width: 100%;
+}
+
+.question-card {
+    background: var(--white);
+    border: none;
+    border-radius: var(--border-radius-small);
+    padding: 1.5rem;
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    cursor: pointer;
+    transition: var(--transition);
+    box-shadow: var(--shadow-soft);
+    text-align: left;
+    position: relative;
+    overflow: hidden;
+    width: 100%;
+}
+
+.question-card::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: -100%;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.4), transparent);
+    transition: var(--transition);
+}
+
+.question-card:hover::before {
+    left: 100%;
+}
+
+.question-card:hover {
+    transform: translateY(-5px);
+    box-shadow: var(--shadow-medium);
+}
+
+.card-icon {
+    width: 50px;
+    height: 50px;
+    background: linear-gradient(135deg, var(--primary-pink-lightest), var(--secondary-pink));
+    border-radius: 12px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1.2rem;
+    color: var(--primary-pink);
+    flex-shrink: 0;
+    transition: var(--transition);
+}
+
+.question-card:hover .card-icon {
+    transform: scale(1.1);
+    background: linear-gradient(135deg, var(--primary-pink), var(--accent-pink));
+    color: var(--white);
+}
+
+.card-content {
+    flex: 1;
+    min-width: 0;
+}
+
+.card-content h3 {
+    font-size: clamp(0.9rem, 1.5vw, 1rem);
+    font-weight: 600;
+    color: var(--text-dark);
+    margin-bottom: 0.25rem;
+    line-height: 1.4;
+    word-wrap: break-word;
+}
+
+.card-arrow {
+    color: var(--gray-medium);
+    transition: var(--transition);
+    flex-shrink: 0;
+}
+
+.question-card:hover .card-arrow {
+    color: var(--primary-pink);
+    transform: translateX(5px);
+}
+
+.predefined-card {
+    border-left: 4px solid var(--primary-pink);
+    background: linear-gradient(135deg, var(--white), var(--white-soft));
+}
+
+.card-icon.symptoms {
+    background: linear-gradient(135deg, #4CAF50, #45a049) !important;
+    color: white !important;
+}
+
+.card-icon.pain {
+    background: linear-gradient(135deg, #FF6B6B, #FF5252) !important;
+    color: white !important;
+}
+
+.card-icon.emotional {
+    background: linear-gradient(135deg, #FFD93D, #FFCD38) !important;
+    color: white !important;
+}
+
+.card-icon.exercise {
+    background: linear-gradient(135deg, #6BCF7F, #4CAF50) !important;
+    color: white !important;
+}
+
+.card-icon.nutrition {
+    background: linear-gradient(135deg, #A78BFA, #8B5CF6) !important;
+    color: white !important;
+}
+
+.card-icon.general {
+    background: linear-gradient(135deg, #4FC3F7, #29B6F6) !important;
+    color: white !important;
+}
+
+/* ===== OPTIMIZED URDU LANGUAGE STYLING - MATCHING ENGLISH SIZE ===== */
+/* ===== OPTIMIZED URDU LANGUAGE STYLING - MATCHING ENGLISH SIZE ===== */
+.urdu-text {
+    font-family: 'Noto Nastaliq Urdu', 'Noto Naskh Arabic', 'Scheherazade New', 'Lateef', 'Amiri', serif !important;
+    direction: rtl !important;
+    text-align: right !important;
+    line-height: 1.8 !important;
+    font-size: 1em !important;
+    font-weight: 400 !important;
+    letter-spacing: 0 !important;
+    word-spacing: normal !important;
+}
+
+/* Urdu Chat Messages */
+.message.urdu-text .message-content p {
+    font-family: 'Noto Nastaliq Urdu', 'Scheherazade New', 'Lateef', serif !important;
+    font-size: 1em !important;
+    line-height: 2.0 !important;
+    text-align: right !important;
+    direction: rtl !important;
+    margin: 0 !important;
+    padding: 0 !important;
+    font-feature-settings: "kern" 1, "liga" 1, "clig" 1, "calt" 1;
+}
+
+/* Urdu Input Field */
+#userInput[style*="direction: rtl"],
+#userInput[style*="text-align: right"] {
+    font-family: 'Noto Nastaliq Urdu', 'Noto Naskh Arabic', 'Scheherazade New', 'Segoe UI', Tahoma, sans-serif !important;
+    font-size: 1em !important;
+    direction: rtl !important;
+    text-align: right !important;
+    line-height: 1.8 !important;
+}
+
+/* Urdu Questions Section */
+#urdu-tab .questions-grid,
+.urdu-questions .question-card {
+    font-family: 'Noto Nastaliq Urdu', 'Scheherazade New', 'Lateef', Tahoma, sans-serif !important;
+    font-size: 1em !important;
+    line-height: 1.8 !important;
+    direction: rtl !important;
+    text-align: right !important;
+}
+
+/* Urdu Empty States */
+#urdu-tab .empty-state {
+    font-family: 'Noto Nastaliq Urdu', 'Scheherazade New', 'Lateef', Tahoma, sans-serif !important;
+    direction: rtl !important;
+    font-size: 1em !important;
+    line-height: 1.8 !important;
+}
+
+/* Urdu Language Badge */
+.language-badge {
+    font-family: 'Noto Naskh Arabic', 'Segoe UI', Tahoma, sans-serif !important;
+    font-size: 0.75em !important;
+    font-weight: 600 !important;
+    background: linear-gradient(135deg, #667eea, #764ba2) !important;
+    color: white !important;
+    padding: 4px 10px !important;
+    border-radius: 12px !important;
+    margin-top: 8px !important;
+    display: inline-block !important;
+}
+
+/* Enhanced Text Rendering for Urdu */
+.urdu-text,
+[lang="ur"],
+[dir="rtl"] {
+    text-rendering: optimizeLegibility !important;
+    -webkit-font-smoothing: antialiased !important;
+    -moz-osx-font-smoothing: grayscale !important;
+    font-feature-settings: "kern" 1, "liga" 1, "clig" 1, "calt" 1;
+}
+
+/* Urdu Tab Button */
+.tab-btn[data-tab="urdu"] {
+    font-family: 'Noto Naskh Arabic', 'Segoe UI', Tahoma, sans-serif !important;
+    font-weight: 600 !important;
+    font-size: 0.9em !important;
+}
+
+/* Urdu Text Card Specific */
+.urdu-text .card-content {
+    text-align: right !important;
+    direction: rtl !important;
+}
+
+.urdu-text.question-card {
+    border-left: none !important;
+    border-right: 4px solid var(--primary-pink) !important;
+}
+
+.urdu-text.question-card:hover {
+    transform: translateX(-5px) translateY(-5px) !important;
+}
+
+.chat-section {
+    animation: slideInRight 1s ease-out 0.5s both;
+    width: 100%;
+}
+
+@keyframes slideInRight {
+    from {
+        opacity: 0;
+        transform: translateX(30px);
+    }
+    to {
+        opacity: 1;
+        transform: translateX(0);
+    }
+}
+
+.chat-container {
+    background: var(--white);
+    border-radius: var(--border-radius);
+    box-shadow: var(--shadow-strong);
+    overflow: hidden;
+    height: 700px;
+    display: flex;
+    flex-direction: column;
+    position: relative;
+    width: 100%;
+}
+
+.chat-header {
+    background: linear-gradient(135deg, var(--white-soft), var(--white-softer));
+    padding: 1.5rem 2rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    border-bottom: 1px solid var(--gray-light);
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+.chat-profile {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    flex: 1;
+    min-width: 0;
+}
+
+.profile-avatar {
+    position: relative;
+    width: 60px;
+    height: 60px;
+    background: linear-gradient(135deg, var(--primary-pink), var(--accent-pink));
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1.5rem;
+    color: var(--white);
+    box-shadow: var(--shadow-soft);
+    flex-shrink: 0;
+}
+
+.online-indicator {
+    position: absolute;
+    bottom: 4px;
+    right: 4px;
+    width: 14px;
+    height: 14px;
+    background: #4CAF50;
+    border: 2px solid var(--white);
+    border-radius: 50%;
+}
+
+.profile-info {
+    min-width: 0;
+}
+
+.profile-info h3 {
+    font-size: clamp(1.1rem, 2vw, 1.3rem);
+    font-weight: 600;
+    color: var(--text-dark);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.profile-info p {
+    color: var(--text-secondary);
+    font-size: clamp(0.8rem, 1.5vw, 0.9rem);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.chat-stats {
+    display: flex;
+    gap: 1.5rem;
+    flex-shrink: 0;
+}
+
+.stat {
+    text-align: center;
+}
+
+.stat-number {
+    display: block;
+    font-size: clamp(1rem, 1.5vw, 1.1rem);
+    font-weight: 600;
+    color: var(--primary-pink);
+}
+
+.stat-label {
+    font-size: clamp(0.7rem, 1.2vw, 0.8rem);
+    color: var(--text-secondary);
+}
+
+.chat-messages {
+    flex: 1;
+    overflow-y: auto;
+    padding: 2rem;
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+    background: var(--white-softer);
+    width: 100%;
+}
+
+.message {
+    display: flex;
+    gap: 1rem;
+    max-width: 85%;
+    animation: messageAppear 0.4s cubic-bezier(0.175, 0.885, 0.32, 1.275);
+    width: fit-content;
+}
+
+@keyframes messageAppear {
+    from {
+        opacity: 0;
+        transform: translateY(20px) scale(0.95);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0) scale(1);
+    }
+}
+
+.user-message {
+    align-self: flex-end;
+    flex-direction: row-reverse;
+}
+
+.system-message {
+    align-self: flex-start;
+}
+
+.message-avatar {
+    width: 45px;
+    height: 45px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1.1rem;
+    flex-shrink: 0;
+    margin-top: 0.5rem;
+}
+
+.user-message .message-avatar {
+    background: linear-gradient(135deg, var(--primary-pink), var(--accent-pink));
+    color: var(--white);
+}
+
+.system-message .message-avatar {
+    background: linear-gradient(135deg, var(--primary-pink-lightest), var(--secondary-pink));
+    color: var(--primary-pink);
+}
+
+.message-content {
+    background: var(--white);
+    padding: 1.2rem 1.5rem;
+    border-radius: 20px;
+    box-shadow: var(--shadow-soft);
+    position: relative;
+    transition: var(--transition-fast);
+    max-width: 100%;
+    word-wrap: break-word;
+}
+
+.user-message .message-content {
+    background: linear-gradient(135deg, var(--primary-pink), var(--accent-pink));
+    color: var(--white);
+    border-bottom-right-radius: 5px;
+}
+
+.system-message .message-content {
+    background: var(--white);
+    color: var(--text-dark);
+    border-bottom-left-radius: 5px;
+}
+
+.message-content::before {
+    content: '';
+    position: absolute;
+    bottom: 0;
+    width: 15px;
+    height: 15px;
+}
+
+.user-message .message-content::before {
+    right: -8px;
+    background: linear-gradient(135deg, var(--primary-pink), var(--accent-pink));
+    clip-path: polygon(0 0, 100% 0, 100% 100%);
+}
+
+.system-message .message-content::before {
+    left: -8px;
+    background: var(--white);
+    clip-path: polygon(0 0, 100% 0, 0 100%);
+}
+
+.message-content p {
+    line-height: 1.6;
+    margin-bottom: 0.5rem;
+    word-wrap: break-word;
+}
+
+.message-time {
+    font-size: 0.75rem;
+    opacity: 0.7;
+}
+
+.typing-indicator {
+    display: none;
+    align-items: center;
+    gap: 1rem;
+    padding: 1rem 2rem;
+    background: var(--white-softer);
+    border-top: 1px solid var(--gray-light);
+    width: 100%;
+}
+
+.typing-dots {
+    display: flex;
+    gap: 4px;
+}
+
+.typing-dots span {
+    width: 8px;
+    height: 8px;
+    background: var(--primary-pink);
+    border-radius: 50%;
+    animation: typing 1.4s infinite ease-in-out;
+}
+
+.typing-dots span:nth-child(1) { animation-delay: -0.32s; }
+.typing-dots span:nth-child(2) { animation-delay: -0.16s; }
+
+@keyframes typing {
+    0%, 80%, 100% { 
+        transform: scale(0.8); 
+        opacity: 0.5; 
+    }
+    40% { 
+        transform: scale(1); 
+        opacity: 1; 
+    }
+}
+
+.typing-indicator p {
+    color: var(--text-secondary);
+    font-size: clamp(0.8rem, 1.5vw, 0.9rem);
+}
+
+.chat-input-container {
+    padding: 1.5rem 2rem;
+    border-top: 1px solid var(--gray-light);
+    background: var(--white);
+    width: 100%;
+}
+
+.input-wrapper {
+    display: flex;
+    gap: 1rem;
+    margin-bottom: 0.5rem;
+    width: 100%;
+}
+
+#userInput {
+    flex: 1;
+    border: none;
+    outline: none;
+    padding: 1.2rem 1.5rem;
+    font-size: clamp(0.9rem, 1.5vw, 1rem);
+    background: var(--white-softer);
+    border-radius: 50px;
+    box-shadow: inset 0 2px 10px rgba(0, 0, 0, 0.05);
+    transition: var(--transition);
+    border: 2px solid transparent;
+    min-width: 0;
+}
+
+#userInput:focus {
+    border-color: var(--primary-pink-light);
+    box-shadow: 0 0 0 3px rgba(255, 107, 147, 0.1), inset 0 2px 10px rgba(0, 0, 0, 0.05);
+}
+
+.send-button {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 1.2rem 1.8rem;
+    background: linear-gradient(135deg, var(--primary-pink), var(--accent-pink));
+    color: var(--white);
+    border: none;
+    border-radius: 50px;
+    cursor: pointer;
+    transition: var(--transition);
+    font-weight: 500;
+    box-shadow: var(--shadow-soft);
+    flex-shrink: 0;
+}
+
+.send-button:hover {
+    transform: translateY(-2px);
+    box-shadow: var(--shadow-medium);
+}
+
+.send-button:active {
+    transform: translateY(0);
+}
+
+.voice-button {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 1.2rem 1.4rem;
+  background: linear-gradient(135deg, var(--primary-pink-lightest), var(--secondary-pink));
+  color: var(--primary-pink);
+  border: none;
+  border-radius: 50%;
+  cursor: pointer;
+  transition: var(--transition);
+  box-shadow: var(--shadow-soft);
+}
+
+.voice-button.recording {
+  background: linear-gradient(135deg, #ff4d7a, #ff6b93);
+  color: white;
+  animation: pulse 1s infinite;
+}
+
+.voice-button:hover {
+  transform: scale(1.1);
+}
+
+.input-hint {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    font-size: clamp(0.7rem, 1.2vw, 0.8rem);
+    color: var(--text-secondary);
+    padding-left: 1rem;
+    flex-wrap: wrap;
+}
+
+.input-hint i {
+    color: var(--primary-pink);
+}
+
+.chat-messages::-webkit-scrollbar {
+    width: 6px;
+}
+
+.chat-messages::-webkit-scrollbar-track {
+    background: rgba(0, 0, 0, 0.05);
+    border-radius: 3px;
+}
+
+.chat-messages::-webkit-scrollbar-thumb {
+    background: var(--primary-pink-light);
+    border-radius: 3px;
+}
+
+.chat-messages::-webkit-scrollbar-thumb:hover {
+    background: var(--primary-pink);
+}
+
+.empty-state {
+    text-align: center;
+    padding: 3rem 2rem;
+    color: var(--text-secondary);
+    width: 100%;
+}
+
+.empty-state i {
+    font-size: clamp(2.5rem, 5vw, 3rem);
+    margin-bottom: 1rem;
+    color: var(--primary-pink-light);
+}
+
+.empty-state p {
+    font-size: clamp(0.9rem, 1.5vw, 1rem);
+    line-height: 1.5;
+}
+
+#activeLanguage {
+    color: var(--primary-pink);
+    font-weight: 600;
+}
+
+#currentLanguageDisplay {
+    color: var(--primary-pink);
+    font-weight: 600;
+}
+
+.audio-message {
+    margin: 10px 0;
+}
+
+.audio-message-container {
+    background: #f8f9fa;
+    border-radius: 18px;
+    padding: 12px 16px;
+    max-width: 280px;
+    border: 1px solid #e9ecef;
+}
+
+.user-audio .audio-message-container {
+    background: #007bff;
+    color: white;
+}
+
+.audio-player-wrapper {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.voice-note-player {
+    flex: 1;
+    height: 32px;
+    border-radius: 16px;
+    background: white;
+    border: 1px solid #ddd;
+}
+
+.user-audio .voice-note-player {
+    background: #0056b3;
+    border-color: #004085;
+}
+
+.audio-visualizer {
+    display: flex;
+    align-items: center;
+    gap: 2px;
+    height: 20px;
+}
+
+.audio-wave {
+    width: 3px;
+    height: 8px;
+    background: #6c757d;
+    border-radius: 2px;
+    transition: all 0.3s ease;
+}
+
+.audio-visualizer.playing .audio-wave {
+    background: #007bff;
+}
+
+.user-audio .audio-wave {
+    background: rgba(255, 255, 255, 0.6);
+}
+
+.user-audio .audio-visualizer.playing .audio-wave {
+    background: white;
+}
+
+.audio-duration {
+    font-size: 11px;
+    color: #6c757d;
+    margin-top: 4px;
+    text-align: center;
+}
+
+.user-audio .audio-duration {
+    color: rgba(255, 255, 255, 0.8);
+}
+
+@keyframes pulse {
+    0% {
+        height: 8px;
+        opacity: 0.7;
+    }
+    100% {
+        height: 16px;
+        opacity: 1;
+    }
+}
+
+.manual-play-required .audio-player-wrapper::before {
+    content: "Click to play";
+    position: absolute;
+    top: -20px;
+    left: 50%;
+    transform: translateX(-50%);
+    background: #ffc107;
+    color: #212529;
+    padding: 4px 8px;
+    border-radius: 4px;
+    font-size: 10px;
+    white-space: nowrap;
+}
+
+.message {
+    opacity: 0;
+    transform: translateY(20px) scale(0.95);
+    transition: all 0.3s ease;
+}
+
+.message.show {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+}
+
+#voiceButton.recording {
+    background: #dc3545;
+    animation: pulse 1.5s infinite;
+}
+
+@keyframes pulse {
+    0% {
+        box-shadow: 0 0 0 0 rgba(220, 53, 69, 0.7);
+    }
+    70% {
+        box-shadow: 0 0 0 10px rgba(220, 53, 69, 0);
+    }
+    100% {
+        box-shadow: 0 0 0 0 rgba(220, 53, 69, 0);
+    }
+}
+
+@media (max-width: 768px) {
+    .urdu-text {
+        font-size: 0.95em;
+        line-height: 1.7;
+    }
+    
+    .chat-messages .message.urdu-text .message-content p {
+        font-size: 0.95em;
+        line-height: 1.9;
+    }
+    
+    .audio-message-container {
+        max-width: 220px;
+    }
+    
+    .voice-note-player {
+        height: 28px;
+    }
+}
+@media (max-width: 1200px) {
+    .container {
+        padding: 1.5rem;
+    }
+    
+    .main-content {
+        gap: 2rem;
+    }
+    
+    .chat-container {
+        height: 650px;
+    }
+}
+
+@media (max-width: 1024px) {
+    .main-content {
+        grid-template-columns: 1fr;
+        gap: 2rem;
+    }
+    
+    .chat-container {
+        height: 600px;
+    }
+    
+    .chat-header {
+        padding: 1.25rem;
+    }
+    
+    .chat-messages {
+        padding: 1.5rem;
+    }
+}
+
+@media (max-width: 768px) {
+    .container {
+        padding: 1rem;
+    }
+    
+    .logo-container {
+        flex-direction: column;
+        text-align: center;
+        gap: 0.5rem;
+    }
+    
+    .title {
+        font-size: 2.5rem;
+    }
+    
+    .chat-header {
+        padding: 1rem;
+        flex-direction: column;
+        gap: 1rem;
+        align-items: flex-start;
+    }
+    
+    .chat-profile {
+        width: 100%;
+    }
+    
+    .chat-stats {
+        align-self: stretch;
+        justify-content: space-around;
+    }
+    
+    .message {
+        max-width: 95%;
+    }
+    
+    .chat-messages {
+        padding: 1rem;
+        gap: 1rem;
+    }
+    
+    .chat-input-container {
+        padding: 1rem;
+    }
+    
+    .input-wrapper {
+        flex-direction: column;
+    }
+    
+    .send-button {
+        align-self: flex-end;
+        width: fit-content;
+        padding: 1rem 1.5rem;
+    }
+    
+    .tabs {
+        flex-direction: column;
+        gap: 0.5rem;
+    }
+    
+    .tab-btn {
+        padding: 1rem;
+        text-align: center;
+    }
+    
+    .question-card {
+        padding: 1.25rem;
+    }
+    
+    .card-icon {
+        width: 45px;
+        height: 45px;
+        font-size: 1.1rem;
+    }
+    
+    .empty-state {
+        padding: 2rem 1rem;
+    }
+    
+    .profile-avatar {
+        width: 50px;
+        height: 50px;
+        font-size: 1.3rem;
+    }
+}
+
+@media (max-width: 480px) {
+    .container {
+        padding: 0.75rem;
+    }
+    
+    .header {
+        margin-bottom: 2rem;
+    }
+    
+    .logo {
+        width: 60px;
+        height: 60px;
+        font-size: 1.7rem;
+    }
+    
+    .title {
+        font-size: 2rem;
+    }
+    
+    .subtitle {
+        font-size: 1rem;
+    }
+    
+    .compassion-message {
+        font-size: 0.85rem;
+    }
+    
+    .main-content {
+        gap: 1.5rem;
+    }
+    
+    .section-header {
+        margin-bottom: 1.5rem;
+    }
+    
+    .section-title {
+        font-size: 1.3rem;
+    }
+    
+    .chat-container {
+        height: 550px;
+        border-radius: 20px;
+    }
+    
+    .chat-messages {
+        padding: 0.75rem;
+        gap: 0.75rem;
+    }
+    
+    .message-content {
+        padding: 1rem 1.25rem;
+    }
+    
+    .message-avatar {
+        width: 40px;
+        height: 40px;
+        font-size: 1rem;
+    }
+    
+    .question-card {
+        padding: 1rem;
+        gap: 0.75rem;
+    }
+    
+    .card-icon {
+        width: 40px;
+        height: 40px;
+        font-size: 1rem;
+    }
+    
+    .floating-element {
+        display: none;
+    }
+    
+    .floating-element.el-1,
+    .floating-element.el-2 {
+        display: block;
+        width: 100px;
+        height: 100px;
+    }
+}
+
+@media (max-width: 360px) {
+    .container {
+        padding: 0.5rem;
+    }
+    
+    .chat-container {
+        height: 500px;
+    }
+    
+    .chat-header {
+        padding: 0.75rem;
+    }
+    
+    .profile-avatar {
+        width: 45px;
+        height: 45px;
+        font-size: 1.2rem;
+    }
+    
+    .chat-stats {
+        gap: 1rem;
+    }
+    
+    .question-card {
+        flex-direction: column;
+        text-align: center;
+        gap: 0.5rem;
+    }
+    
+    .card-content h3 {
+        text-align: center;
+    }
+    
+    .urdu-text.question-card {
+        flex-direction: column;
+    }
+    
+    .urdu-text .card-content {
+        text-align: center;
+    }
+}
+
+@media print {
+    .floating-elements,
+    .send-button,
+    .typing-indicator,
+    .chat-input-container {
+        display: none !important;
+    }
+    
+    .chat-container {
+        box-shadow: none;
+        height: auto;
+    }
+    
+    .chat-messages {
+        overflow: visible;
+    }
+}