Update app.py

app.py

@@ -1,480 +1,318 @@
 import gradio as gr
 import librosa
 import numpy as np
+import torch
+from transformers import WhisperProcessor, WhisperForConditionalGeneration
+from simple_salesforce import Salesforce
 import os
-import hashlib
 from datetime import datetime
-from transformers import pipeline
-import soundfile
-import torch
-from tenacity import retry, stop_after_attempt, wait_fixed
 import logging
+import webrtcvad
+import google.generativeai as genai
+from gtts import gTTS
 import tempfile
-import shutil
-from simple_salesforce import Salesforce
-from dotenv import load_dotenv
-import pyttsx3
-from cryptography.fernet import Fernet
-import asyncio
-import base64
-import traceback
 
-# Set up logging
-logging.basicConfig(
-    level=logging.DEBUG,
-    format="%(asctime)s - %(levelname)s - %(message)s",
-    handlers=[logging.FileHandler("voice_analyzer.log"), logging.StreamHandler()]
-)
+# Set up logging for usage metrics and debugging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
+usage_metrics = {"total_assessments": 0}
 
-# Load environment variables
-load_dotenv()
-
-# Salesforce configuration
+# Environment variables for secure credentials
 SF_USERNAME = os.getenv("SF_USERNAME")
 SF_PASSWORD = os.getenv("SF_PASSWORD")
 SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
-SF_ENABLED = all([SF_USERNAME, SF_PASSWORD, SF_SECURITY_TOKEN])
+SF_INSTANCE_URL = os.getenv("SF_INSTANCE_URL", "https://login.salesforce.com")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "AIzaSyBzr5vVpbe8CV1v70l3pGDp9vRJ76yCxdk")
+
+# Initialize Salesforce
 sf = None
-if SF_ENABLED:
-    try:
+try:
+    if all([SF_USERNAME, SF_PASSWORD, SF_SECURITY_TOKEN]):
         sf = Salesforce(
             username=SF_USERNAME,
             password=SF_PASSWORD,
-            security_token=SF_SECURITY_TOKEN
-        )
-        logger.info("Salesforce connection established")
-    except Exception as e:
-        logger.error(f"Salesforce connection failed: {str(e)}")
-        SF_ENABLED = False
-
-# Encryption setup (AES-256)
-ENCRYPTION_KEY = os.getenv("ENCRYPTION_KEY") or Fernet.generate_key()
-fernet = Fernet(ENCRYPTION_KEY)
-
-# Initialize text-to-speech with fallback
-tts_engine = None
-try:
-    tts_engine = pyttsx3.init()
-    tts_engine.setProperty("rate", 150)
-    logger.info("pyttsx3 initialized successfully")
-except Exception as e:
-    logger.warning(f"Failed to initialize pyttsx3: {str(e)}. Text-to-speech disabled.")
-
-# Initialize local models
-@retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
-def load_whisper_model():
-    try:
-        model = pipeline(
-            "automatic-speech-recognition",
-            model="openai/whisper-large-v3",
-            device=-1,  # CPU; use device=0 for GPU
-            model_kwargs={"use_safetensors": True}
-        )
-        logger.info("Whisper-large-v3 model loaded successfully")
-        return model
-    except Exception as e:
-        logger.error(f"Failed to load Whisper model: {str(e)}")
-        raise
-
-@retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
-def load_symptom_model():
-    try:
-        model = pipeline(
-            "text-classification",
-            model="abhirajeshbhai/symptom-2-disease-net",
-            device=-1,
-            model_kwargs={"use_safetensors": True},
-            return_all_scores=False
+            security_token=SF_SECURITY_TOKEN,
+            instance_url=SF_INSTANCE_URL
         )
-        logger.info("Symptom-2-Disease model loaded successfully")
-        return model
-    except Exception as e:
-        logger.error(f"Failed to load Symptom-2-Disease model: {str(e)}")
-        # Disable fallback for now to isolate issue
-        raise
-
-whisper = None
-symptom_classifier = None
-is_fallback_model = False
-
-try:
-    whisper = load_whisper_model()
+        logger.info("Connected to Salesforce for user management")
+    else:
+        logger.warning("Salesforce credentials missing; user management disabled")
 except Exception as e:
-    logger.error(f"Whisper model initialization failed: {str(e)}")
+    logger.error(f"Salesforce connection failed: {str(e)}")
 
+# Initialize Google Gemini
 try:
-    symptom_classifier = load_symptom_model()
+    genai.configure(api_key=GEMINI_API_KEY)
+    gemini_model = genai.GenerativeModel('gemini-1.5-flash')
+    chat = gemini_model.start_chat(history=[])
+    logger.info("Connected to Google Gemini for chatbot functionality")
 except Exception as e:
-    logger.error(f"Symptom model initialization failed: {str(e)}")
-    symptom_classifier = None
-
-def encrypt_data(data):
-    """Encrypt data using AES-256."""
-    try:
-        if isinstance(data, str):
-            data = data.encode()
-        return fernet.encrypt(data).decode()
-    except Exception as e:
-        logger.error(f"Encryption failed: {str(e)}")
-        return None
-
-def decrypt_data(data):
-    """Decrypt AES-256 encrypted data."""
-    try:
-        return fernet.decrypt(data.encode()).decode()
-    except Exception as e:
-        logger.error(f"Decryption failed: {str(e)}")
-        return None
-
-def compute_file_hash(file_path):
-    """Compute MD5 hash of encrypted file."""
-    try:
-        hash_md5 = hashlib.md5()
-        with open(file_path, "rb") as f:
-            for chunk in iter(lambda: f.read(4096), b""):
-                hash_md5.update(chunk)
-        return hash_md5.hexdigest()
-    except Exception as e:
-        logger.error(f"Failed to compute file hash: {str(e)}")
-        return "unknown"
-
-def ensure_writable_dir(directory):
-    """Ensure directory exists and is writable."""
+    logger.error(f"Google Gemini initialization failed: {str(e)}")
+    chat = None
+
+# Load Whisper model for speech-to-text
+whisper_processor = WhisperProcessor.from_pretrained("openai/whisper-tiny")
+whisper_model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny")
+whisper_model.config.forced_decoder_ids = whisper_processor.get_decoder_prompt_ids(language="english", task="transcribe")
+
+# Initialize VAD
+vad = webrtcvad.Vad(mode=2)
+
+# Chatbot knowledge base
+base_info = """
+You are a highly advanced AI assistant named 'MindCare'.
+Your role is to provide support in various aspects of health and well-being, including:
+- **Mental health**: Emotional support, mindfulness, stress-relief exercises, anxiety management.
+- **Medical guidance**: Basic symptom analysis, possible conditions, and medicine recommendations.
+- **Decision-making support**: Helping users with personal, professional, and emotional choices.
+- **General health advice**: Lifestyle improvements, nutrition, physical wellness, and mental well-being.
+- **Emergency assistance**: If the user is in distress, suggest professional help or helpline numbers.
+Your tone is always **empathetic, supportive, and informative**. You ensure users feel heard and cared for.
+"""
+mental_health = """
+If the user is feeling stressed or anxious:
+- Suggest mindfulness exercises, deep breathing techniques, or gratitude journaling.
+- Encourage taking breaks, engaging in hobbies, and spending time in nature.
+- Provide positive affirmations and self-care routines.
+If the user is in distress:
+- Offer emotional support and let them know they are not alone.
+- Encourage them to reach out to a trusted person or professional.
+- Provide emergency helpline numbers if needed.
+"""
+medical_assistance = """
+If the user provides symptoms:
+- Analyze symptoms and suggest possible conditions.
+- Provide general advice but **never** replace a doctor’s consultation.
+- Suggest lifestyle changes or basic home remedies if applicable.
+- If symptoms are severe, advise them to visit a healthcare professional.
+If the user asks about medicines:
+- Suggest **common antibiotics** based on infection type (e.g., Amoxicillin for bacterial infections).
+- Recommend **painkillers** like Paracetamol, Ibuprofen, or Diclofenac for pain relief.
+- Mention precautions and possible side effects.
+- Clearly **state that a doctor’s consultation is necessary before taking any medicine**.
+"""
+medicine_recommendation = """
+If the user asks for a prescription, provide general guidance on **commonly used medicines**:
+- **Antibiotics** (for bacterial infections): Amoxicillin, Azithromycin, Ciprofloxacin.
+- **Painkillers**: Paracetamol (mild pain/fever), Ibuprofen (anti-inflammatory), Diclofenac (muscle pain).
+- **Cold & Flu**: Antihistamines like Cetirizine, Cough syrups like Dextromethorphan.
+- **Stomach Issues**: Antacids like Ranitidine, PPI like Omeprazole.
+Always remind the user that **only a licensed doctor can prescribe medicines, and misuse can be harmful**.
+"""
+decision_guidance = """
+If the user is struggling with a decision:
+- Help them weigh pros and cons logically.
+- Suggest considering their values, long-term goals, and emotions.
+- Provide structured approaches like decision matrices or intuitive checks.
+- Encourage seeking advice from trusted people if needed.
+"""
+emergency_help = """
+If the user mentions severe mental distress:
+- Respond with immediate emotional support.
+- Provide crisis helpline numbers (if applicable to the region).
+- Encourage talking to a trusted friend, family member, or professional.
+- Remind them that they are not alone and help is available.
+"""
+context = [base_info, mental_health, medical_assistance, medicine_recommendation, decision_guidance, emergency_help]
+
+def extract_health_features(audio, sr):
     try:
-        os.makedirs(directory, exist_ok=True)
-        test_file = os.path.join(directory, "test")
-        with open(test_file, "w") as f:
-            f.write("test")
-        os.remove(test_file)
-        logger.debug(f"Directory {directory} is writable")
-        return True
+        audio = audio / np.max(np.abs(audio)) if np.max(np.abs(audio)) != 0 else audio
+        frame_duration = 30
+        frame_samples = int(sr * frame_duration / 1000)
+        frames = [audio[i:i + frame_samples] for i in range(0, len(audio), frame_samples)]
+        voiced_frames = [
+            frame for frame in frames
+            if len(frame) == frame_samples and vad.is_speech((frame * 32768).astype(np.int16).tobytes(), sr)
+        ]
+        if not voiced_frames:
+            raise ValueError("No voiced segments detected")
+        voiced_audio = np.concatenate(voiced_frames)
+        pitches, magnitudes = librosa.piptrack(y=voiced_audio, sr=sr, fmin=75, fmax=300)
+        valid_pitches = [p for p in pitches[magnitudes > 0] if 75 <= p <= 300]
+        pitch = np.mean(valid_pitches) if valid_pitches else 0
+        jitter = np.std(valid_pitches) / pitch if pitch and valid_pitches else 0
+        if jitter > 10:
+            jitter = 10
+            logger.warning("Jitter capped at 10%")
+        amplitudes = librosa.feature.rms(y=voiced_audio, frame_length=2048, hop_length=512)[0]
+        shimmer = np.std(amplitudes) / np.mean(amplitudes) if np.mean(amplitudes) else 0
+        if shimmer > 10:
+            shimmer = 10
+            logger.warning("Shimmer capped at 10%")
+        energy = np.mean(librosa.feature.rms(y=voiced_audio, frame_length=2048, hop_length=512)[0])
+        return {
+            "pitch": pitch,
+            "jitter": jitter * 100,
+            "shimmer": shimmer * 100,
+            "energy": energy
+        }
     except Exception as e:
-        logger.error(f"Directory {directory} not writable: {str(e)}")
-        return False
+        logger.error(f"Feature extraction failed: {str(e)}")
+        raise
 
-async def transcribe_audio(audio_file, language="en"):
-    """Transcribe audio using Whisper model."""
-    if not whisper:
-        logger.error("Whisper model not loaded")
-        return "Error: Whisper model not loaded"
+def transcribe_audio(audio):
     try:
-        logger.debug(f"Transcribing audio: {audio_file} (language: {language})")
-        if not isinstance(audio_file, (str, bytes, os.PathLike)) or not os.path.exists(audio_file):
-            logger.error(f"Invalid or missing audio file: {audio_file}")
-            return "Error: Invalid or missing audio file"
-        audio, sr = librosa.load(audio_file, sr=16000)
-        if len(audio) < 1600:
-            logger.error("Audio too short")
-            return "Error: Audio too short (<0.1s)"
-        if np.max(np.abs(audio)) < 1e-4:
-            logger.error("Audio too quiet")
-            return "Error: Audio too quiet"
-
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_wav:
-            temp_path = temp_wav.name
-            soundfile.write(audio, sr, temp_path)
-            logger.debug(f"Saved temp WAV: {temp_path}")
-
+        inputs = whisper_processor(audio, sampling_rate=16000, return_tensors="pt")
         with torch.no_grad():
-            result = whisper(temp_path, language=language, generate_kwargs={"num_beams": 5})
-        transcription = result.get("text", "").strip()
+            generated_ids = whisper_model.generate(inputs["input_features"])
+        transcription = whisper_processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
         logger.info(f"Transcription: {transcription}")
-
-        try:
-            os.remove(temp_path)
-            logger.debug(f"Deleted temp WAV: {temp_path}")
-        except Exception as e:
-            logger.error(f"Failed to delete temp WAV: {str(e)}")
-
-        if not transcription:
-            logger.error("Transcription empty")
-            return "Error: Transcription empty"
-        words = transcription.split()
-        if len(words) > 5 and len(set(words)) < len(words) / 2:
-            logger.error("Transcription repetitive")
-            return "Error: Transcription repetitive"
         return transcription
     except Exception as e:
         logger.error(f"Transcription failed: {str(e)}")
-        return f"Error: {str(e)}"
-
-def analyze_symptoms(text):
-    """Analyze symptoms using Symptom-2-Disease model."""
-    if not symptom_classifier:
-        logger.error("Symptom model not loaded")
-        return "Error: Symptom model not loaded", 0.0
-    try:
-        if not text or not isinstance(text, str) or "Error" in text:
-            logger.error(f"Invalid text input: {text}")
-            return "Error: No valid transcription", 0.0
-
-        with torch.no_grad():
-            result = symptom_classifier(text)
-        logger.debug(f"Raw model output: type={type(result)}, value={result}")
-
-        # Initialize default values
-        prediction = "No health condition detected"
-        score = 0.0
-
-        # Handle expected output: list of dictionaries
-        if isinstance(result, list) and result:
-            valid_items = [
-                item for item in result
-                if isinstance(item, dict) and
-                "label" in item and isinstance(item["label"], str) and
-                "score" in item and isinstance(item["score"], (int, float)) and 0 <= item["score"] <= 1
-            ]
-            if valid_items:
-                sorted_items = sorted(valid_items, key=lambda x: x["score"], reverse=True)
-                prediction = sorted_items[0]["label"]
-                score = sorted_items[0]["score"]
-            else:
-                logger.warning(f"Invalid items in result list: {result}")
-        elif isinstance(result, dict):
-            if "label" in result and "score" in result and isinstance(result["label"], str) and \
-               isinstance(result["score"], (int, float)) and 0 <= result["score"] <= 1:
-                prediction = result["label"]
-                score = result["score"]
-            else:
-                logger.warning(f"Invalid dictionary content: {result}")
-        elif isinstance(result, tuple):
-            logger.warning(f"Received tuple output: {result}")
-            if len(result) == 0:
-                logger.warning("Empty tuple received")
-            elif len(result) > 0:
-                if isinstance(result[0], dict):
-                    if "label" in result[0] and "score" in result[0] and \
-                       isinstance(result[0]["label"], str) and \
-                       isinstance(result[0]["score"], (int, float)) and 0 <= result[0]["score"] <= 1:
-                        prediction = result[0]["label"]
-                        score = result[0]["score"]
-                    else:
-                        logger.warning(f"Invalid dictionary in tuple: {result[0]}")
-                else:
-                    logger.warning(f"First tuple element is not a dict: {result[0]}")
-            else:
-                logger.warning(f"Invalid tuple content: {result}")
-        else:
-            logger.warning(f"Unexpected model output type: {type(result)}, value: {result}")
-
-        # Final validation
-        if not isinstance(prediction, str):
-            logger.warning(f"Invalid label type: {type(prediction)}, value: {prediction}")
-            prediction = "No health condition detected"
-        if not isinstance(score, (int, float)) or score < 0 or score > 1:
-            logger.warning(f"Invalid score: {score}")
-            score = 0.0
-
-        logger.info(f"Prediction: {prediction}, Score: {score:.4f}")
-        return prediction, score
-    except Exception as e:
-        logger.error(f"Symptom analysis failed: {str(e)}")
-        logger.error(f"Stack trace: {traceback.format_exc()}")
-        return "Error: Symptom analysis failed", 0.0
+        return None
 
-def save_to_salesforce(user_id, transcription, prediction, score, feedback, consent_granted):
-    """Save analysis results to Salesforce."""
-    if not SF_ENABLED or not sf:
-        logger.debug("Salesforce integration disabled or not connected")
-        return
+def get_chatbot_response(message):
+    if not chat or not message:
+        return "Unable to generate chatbot response due to missing input or model.", None
+    full_context = "\n".join(context) + f"\nUser: {message}\nMindCare:"
     try:
-        if consent_granted:
-            encrypted_transcription = encrypt_data(transcription)
-            encrypted_feedback = encrypt_data(feedback)
-            sf.Health_Analysis__c.create({
-                "User_ID__c": user_id,
-                "Transcription__c": encrypted_transcription[:255],
-                "Prediction__c": prediction[:255],
-                "Confidence_Score__c": float(score),
-                "Feedback__c": encrypted_feedback[:255],
-                "Analysis_Date__c": datetime.utcnow().strftime("%Y-%m-%d")
-            })
-        logger.info("Saved analysis to Salesforce")
+        response = chat.send_message(full_context).text
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio:
+            tts = gTTS(text=response, lang="en", slow=False)
+            tts.save(temp_audio.name)
+            audio_path = temp_audio.name
+        return response, audio_path
     except Exception as e:
-        logger.error(f"Failed to save to Salesforce: {str(e)}")
+        logger.error(f"Chatbot response failed: {str(e)}")
+        return "Error generating chatbot response.", None
 
-def generate_report():
-    """Generate usage report via Salesforce."""
-    if not SF_ENABLED or not sf:
-        return "Error: Salesforce not connected"
-    try:
-        query = "SELECT COUNT(Id), Prediction__c FROM Health_Analysis__c GROUP BY Prediction__c"
-        result = sf.query(query)
-        report = "Health Analysis Report\n"
-        for record in result["records"]:
-            count = record["expr0"]
-            prediction = record["Prediction__c"]
-            report += f"Condition: {prediction}, Count: {count}\n"
-        logger.info("Generated usage report")
-        return report
-    except Exception as e:
-        logger.error(f"Failed to generate report: {str(e)}")
-        return f"Error: {str(e)}"
-
-async def speak_response(text):
-    """Convert text to speech."""
-    if not tts_engine:
-        logger.warning("Text-to-speech unavailable; skipping")
-        return None
-    try:
-        def sync_speak():
-            tts_engine.say(text)
-            tts_engine.runAndWait()
-        loop = asyncio.get_event_loop()
-        await loop.run_in_executor(None, sync_speak)
-        logger.debug("Speech response generated")
-    except Exception as e:
-        logger.error(f"Text-to-speech failed: {str(e)}")
+def analyze_symptoms(text):
+    text = text.lower()
+    feedback = []
+    if "cough" in text or "difficulty breathing" in text:
+        feedback.append("Based on your input, you may have a respiratory issue, such as bronchitis or asthma. Please consult a doctor.")
+    elif "stressed" in text or "stress" in text or "tired" in text or "fatigue" in text:
+        feedback.append("Your description suggests possible stress or fatigue, potentially linked to anxiety or exhaustion. Consider seeking medical advice.")
+    else:
+        feedback.append("Your input didn’t clearly indicate specific symptoms. Please describe any health concerns (e.g., cough, stress) and consult a healthcare provider.")
+    return "\n".join(feedback)
+
+def analyze_voice(audio_file=None):
+    global usage_metrics
+    usage_metrics["total_assessments"] += 1
+    logger.info(f"Total assessments: {usage_metrics['total_assessments']}")
 
-async def analyze_voice(audio_file, language="en", user_id="anonymous", consent_granted=True):
-    """Analyze voice for health indicators."""
     try:
-        logger.debug(f"Starting analysis for audio_file: {audio_file}, language: {language}")
-        if audio_file is None or not isinstance(audio_file, (str, bytes, os.PathLike)):
-            logger.error(f"Invalid audio file input: {audio_file}")
-            return "Error: No audio file provided"
-        
-        temp_dir = os.path.join(tempfile.gettempdir(), "gradio")
-        if not ensure_writable_dir(temp_dir):
-            fallback_dir = os.path.join(os.getcwd(), "temp_gradio")
-            if not ensure_writable_dir(fallback_dir):
-                logger.error(f"Temp directories {temp_dir} and {fallback_dir} not writable")
-                return "Error: Temp directories not writable"
-            temp_dir = fallback_dir
-        
-        if not os.path.exists(audio_file):
-            logger.error(f"Audio file not found: {audio_file}")
-            return "Error: Audio file not found"
-        
-        unique_path = os.path.join(
-            temp_dir,
-            f"audio_{datetime.utcnow().strftime('%Y%m%d%H%M%S%f')}_{os.path.basename(audio_file or 'unknown.wav')}"
-        )
-        try:
-            shutil.copy(audio_file, unique_path)
-            audio_file = unique_path
-            logger.debug(f"Copied to: {audio_file}")
-        except Exception as e:
-            logger.error(f"Failed to copy audio file: {str(e)}")
-            return f"Error: Failed to copy audio file: {str(e)}"
-        
-        file_hash = compute_file_hash(audio_file)
-        logger.info(f"Processing audio, Hash: {file_hash}")
-        
-        audio, sr = librosa.load(audio_file, sr=16000)
-        logger.info(f"Audio loaded: shape={audio.shape}, SR={sr}, Duration={len(audio)/sr:.2f}s")
-        
-        transcription = await transcribe_audio(audio_file, language)
-        if "Error" in transcription:
-            logger.error(f"Transcription error: {transcription}")
-            return transcription
-        
-        if any(keyword in transcription.lower() for keyword in ["medicine", "treatment"]):
-            logger.warning("Medication query detected")
-            feedback = "Error: This tool does not provide medication advice"
-            await speak_response(feedback)
-            return feedback
-        
-        prediction, score = analyze_symptoms(transcription)
-        if "Error" in prediction:
-            logger.error(f"Symptom analysis error: {prediction}")
-            return prediction
-        
-        feedback = (
-            "No health condition detected, consult a doctor if symptoms persist. This is not a medical diagnosis."
-            if prediction == "No health condition detected"
-            else f"Possible {prediction.lower()} detected based on symptoms like '{transcription.lower()}', consult a doctor. This is not a medical diagnosis."
-        )
-        logger.info(f"Feedback: {feedback}, Transcription: {transcription}, Prediction: {prediction}, Score: {score:.4f}")
-        
-        # Save to Salesforce
-        save_to_salesforce(user_id, transcription, prediction, score, feedback, consent_granted)
-        
-        try:
-            os.remove(audio_file)
-            logger.debug(f"Deleted audio file: {audio_file}")
-        except Exception as e:
-            logger.error(f"Failed to delete audio file: {str(e)}")
-        
-        # Speak response
-        await speak_response(feedback)
-        
-        return feedback
+        if audio_file and os.path.exists(audio_file):
+            audio, sr = librosa.load(audio_file, sr=16000)
+        else:
+            raise ValueError("No valid audio file provided for analysis")
+
+        if len(audio) < sr:
+            raise ValueError("Audio too short (minimum 1 second)")
+
+        features = extract_health_features(audio, sr)
+        transcription = transcribe_audio(audio)
+        symptom_feedback = analyze_symptoms(transcription) if transcription else "No transcription available. Please record again with clear speech."
+
+        feedback = []
+        respiratory_score = features["jitter"]
+        mental_health_score = features["shimmer"]
+
+        if respiratory_score > 1.0:
+            feedback.append(f"Your voice indicates elevated jitter ({respiratory_score:.2f}%), which may suggest respiratory issues. Consult a doctor.")
+        if mental_health_score > 5.0:
+            feedback.append(f"Your voice shows elevated shimmer ({mental_health_score:.2f}%), possibly indicating stress or emotional strain. Consider a health check.")
+        if features["energy"] < 0.01:
+            feedback.append(f"Your vocal energy is low ({features['energy']:.4f}), which might point to fatigue. Seek medical advice if this persists.")
+
+        if not feedback and not symptom_feedback.startswith("No transcription"):
+            feedback.append("Your voice analysis shows no immediate health concerns based on current data.")
+
+        feedback.append("\n**Symptom Feedback (Based on Your Input)**:")
+        feedback.append(symptom_feedback)
+        feedback.append("\n**Voice Analysis Details**:")
+        feedback.append(f"Pitch: {features['pitch']:.2f} Hz (average fundamental frequency)")
+        feedback.append(f"Jitter: {respiratory_score:.2f}% (pitch variation, higher values may indicate respiratory issues)")
+        feedback.append(f"Shimmer: {mental_health_score:.2f}% (amplitude variation, higher values may indicate stress)")
+        feedback.append(f"Energy: {features['energy']:.4f} (vocal intensity, lower values may indicate fatigue)")
+        feedback.append(f"Transcription: {transcription if transcription else 'None'}")
+        feedback.append("\n**Disclaimer**: This is a preliminary analysis, not a medical diagnosis. Always consult a healthcare provider for professional evaluation.")
+
+        feedback_str = "\n".join(feedback)
+
+        if sf:
+            store_in_salesforce(audio_file, feedback_str, respiratory_score, mental_health_score, features, transcription)
+
+        if audio_file and os.path.exists(audio_file):
+            try:
+                os.remove(audio_file)
+                logger.info(f"Deleted audio file: {audio_file} for compliance")
+            except Exception as e:
+                logger.error(f"Failed to delete audio file: {str(e)}")
+
+        return feedback_str
     except Exception as e:
-        logger.error(f"Voice analysis failed: {str(e)}")
+        logger.error(f"Audio processing failed: {str(e)}")
         return f"Error: {str(e)}"
 
-async def test_with_sample_audio(language="en", user_id="anonymous", consent_granted=True):
-    """Test with synthetic audio."""
-    temp_dir = os.path.join(tempfile.gettempdir(), "audio_samples")
-    if not ensure_writable_dir(temp_dir):
-        fallback_dir = os.path.join(os.getcwd(), "temp_audio_samples")
-        if not ensure_writable_dir(fallback_dir):
-            logger.error(f"Temp directories {temp_dir} and {fallback_dir} not writable")
-            return f"Error: Temp directories not writable"
-        temp_dir = fallback_dir
-    
-    sample_audio_path = os.path.join(temp_dir, "dummy_test.wav")
-    logger.info(f"Generating synthetic audio at: {sample_audio_path}")
-    sr = 16000
-    t = np.linspace(0, 2, 2 * sr)
-    freq_mod = 440 + 10 * np.sin(2 * np.pi * 0.5 * t)
-    amplitude_mod = 0.5 + 0.1 * np.sin(2 * np.pi * 0.3 * t)
-    noise = 0.01 * np.random.normal(0, 1, len(t))
-    dummy_audio = amplitude_mod * np.sin(2 * np.pi * freq_mod * t) + noise
+def store_in_salesforce(audio_file, feedback, respiratory_score, mental_health_score, features, transcription):
     try:
-        soundfile.write(dummy_audio, sr, sample_audio_path)
-        logger.info(f"Generated synthetic audio: {sample_audio_path}")
+        sf.HealthAssessment__c.create({
+            "AssessmentDate__c": datetime.utcnow().isoformat(),
+            "Feedback__c": feedback,
+            "RespiratoryScore__c": float(respiratory_score),
+            "MentalHealthScore__c": float(mental_health_score),
+            "AudioFileName__c": os.path.basename(audio_file) if audio_file else "user_recorded_audio",
+            "Pitch__c": float(features["pitch"]),
+            "Jitter__c": float(features["jitter"]),
+            "Shimmer__c": float(features["shimmer"]),
+            "Energy__c": float(features["energy"]),
+            "Transcription__c": transcription or "None"
+        })
+        logger.info("Stored assessment in Salesforce")
     except Exception as e:
-        logger.error(f"Failed to write synthetic audio: {str(e)}")
-        return f"Error: Failed to generate synthetic audio: {str(e)}"
-    
-    if not os.path.exists(sample_audio_path):
-        logger.error(f"Synthetic audio not created: {sample_audio_path}")
-        return f"Error: Synthetic audio not created: {sample_audio_path}"
-    
-    mock_transcription = "I have a cough and sore throat"
-    logger.info(f"Mock transcription: {mock_transcription}")
-    prediction, score = analyze_symptoms(mock_transcription)
-    feedback = (
-        "No health condition detected, consult a doctor if symptoms persist. This is not a medical diagnosis."
-        if prediction == "No health condition detected"
-        else f"Possible {prediction.lower()} detected based on symptoms like '{mock_transcription.lower()}', consult a doctor. This is not a medical diagnosis."
+        logger.error(f"Salesforce storage failed: {str(e)}")
+
+# Combined interface with voice analysis and chatbot suggestions
+with gr.Blocks(title="MindCare Health Assistant") as demo:
+    gr.Markdown("# MindCare Health Assistant")
+    gr.Markdown("This tool is accessible via web and mobile. Use the sections below for health assessments and suggestions.")
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Voice Analysis")
+            gr.Markdown("Record or upload your voice (minimum 1 second) to receive a preliminary health check. Speak clearly in English about your symptoms (e.g., 'I have a cough' or 'I feel stressed').")
+            audio_input = gr.Audio(type="filepath", label="Record or Upload Your Voice (WAV, MP3, FLAC, 1+ sec)", format="wav")
+            voice_output = gr.Textbox(label="Health Assessment Results", elem_id="health-results")
+            submit_btn = gr.Button("Submit")
+            clear_btn = gr.Button("Clear")
+
+        with gr.Column():
+            gr.Markdown("### Health Suggestions")
+            gr.Markdown("Enter a message to get personalized health suggestions from MindCare.")
+            text_input = gr.Textbox(label="Enter your message")
+            text_output = gr.Textbox(label="Response")
+            audio_output = gr.Audio(label="Response Audio")
+            suggest_submit_btn = gr.Button("Submit")
+            suggest_clear_btn = gr.Button("Clear")
+
+    # Voice analysis event
+    submit_btn.click(
+        fn=analyze_voice,
+        inputs=[audio_input],
+        outputs=[voice_output]
+    )
+    clear_btn.click(
+        fn=lambda: (gr.update(value=None), gr.update(value="")),
+        inputs=None,
+        outputs=[audio_input, voice_output]
     )
-    logger.info(f"Test feedback: {feedback}, Prediction: {prediction}, Score: {score:.4f}")
-    
-    # Save to Salesforce
-    save_to_salesforce(user_id, mock_transcription, prediction, score, feedback, consent_granted)
-    
-    try:
-        os.remove(sample_audio_path)
-        logger.debug(f"Deleted test audio: {sample_audio_path}")
-    except Exception:
-        pass
-    return feedback
-
-async def voicebot_interface(audio_file, language="en", user_id="anonymous", consent_granted=True):
-    """Gradio interface wrapper."""
-    return await analyze_voice(audio_file, language, user_id, consent_granted)
 
-# Gradio interface
-iface = gr.Interface(
-    fn=voicebot_interface,
-    inputs=[
-        gr.Audio(type="filepath", label="Record or Upload Voice (WAV, MP3, FLAC, 1+ sec)"),
-        gr.Dropdown(["en", "es", "hi", "zh"], label="Language", value="en"),
-        gr.Textbox(label="User ID (optional)", value="anonymous"),
-        gr.Checkbox(label="Consent to store data", value=True)
-    ],
-    outputs=gr.Textbox(label="Health Assessment Feedback"),
-    title="Smart Voicebot for Public Health",
-    description="Record or upload a voice sample describing symptoms (e.g., 'I have a cough') for preliminary health assessment. Supports English, Spanish, Hindi, Mandarin. Not a diagnostic tool. Data is encrypted and stored with consent. Complies with HIPAA/GDPR."
-)
+    # Chatbot suggestion event
+    suggest_submit_btn.click(
+        fn=get_chatbot_response,
+        inputs=[text_input],
+        outputs=[text_output, audio_output]
+    )
+    suggest_clear_btn.click(
+        fn=lambda: (gr.update(value=""), gr.update(value=""), gr.update(value=None)),
+        inputs=None,
+        outputs=[text_input, text_output, audio_output]
+    )
 
 if __name__ == "__main__":
-    logger.info("Starting Voice Health Analyzer")
-    # Test with synthetic audio
-    loop = asyncio.get_event_loop()
-    print(loop.run_until_complete(test_with_sample_audio()))
-    iface.launch(server_name="0.0.0.0", server_port=7860)
+    logger.info("Starting MindCare Health Analyzer at 02:21 PM IST, June 23, 2025")
+    demo.launch(server_name="0.0.0.0", server_port=7860)