Update app.py

app.py

@@ -1,121 +1,113 @@
 import streamlit as st
 import os
-from transformers import pipeline
-from langdetect import detect, DetectorFactory
 from groq import Groq
+from langdetect import detect, DetectorFactory
+import json
 
 # Ensure consistent language detection
 DetectorFactory.seed = 0
 
-# Load Hugging Face token from environment
-HF_TOKEN = os.environ.get("homeo_doc")
-if not HF_TOKEN:
-    st.error("❌ Missing Hugging Face API token. Set 'homeo_doc' in environment variables.")
-
-# Initialize translation pipeline
-try:
-    translator = pipeline("translation", model="facebook/nllb-200-distilled-600M", token=HF_TOKEN)
-except Exception as e:
-    st.error(f"❌ Error initializing translation model: {e}")
-
-# Initialize Groq client for AI-based homeopathic advice
+# Load API key from environment
 GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
 if not GROQ_API_KEY:
     st.error("❌ Missing GROQ API Key. Set 'GROQ_API_KEY' in environment variables.")
 
+# Initialize Groq client
 groq_client = Groq(api_key=GROQ_API_KEY)
 
-# Language code mapping for NLLB-200
-LANG_CODE_MAP = {
-    'en': 'eng_Latn',    # English
-    'ur': 'urd_Arab',    # Urdu
-    'ar': 'arb_Arab',    # Arabic
-    'es': 'spa_Latn',    # Spanish
-    'hi': 'hin_Deva',    # Hindi
-    'fr': 'fra_Latn'     # French
-}
-
-def translate_text(text, target_lang='eng_Latn'):
-    """Translate text using NLLB-200 model."""
+# Define chatbot role as a specialized homeopathic doctor
+CHATBOT_ROLE = """You are a highly skilled homeopathic doctor specializing in natural remedies. 
+You analyze symptoms provided by users and suggest effective homeopathic treatments based on research-backed sources. 
+Your response must include:
+- Best possible remedy
+- Proper dosage and administration
+- Scientific or historical sources for reference
+- Store/availability of the medicine
+Ensure accuracy in medical details and maintain professionalism."""
+
+def detect_language(text):
+    """Detect the language of the input text."""
     try:
-        source_lang = detect(text)
-        source_code = LANG_CODE_MAP.get(source_lang, 'eng_Latn')  # Default to English if unknown
-        
-        st.write(f"🔄 Detected source: {source_code}, Target: {target_lang}")  # Debugging log
+        lang = detect(text)
+        return lang
+    except:
+        return "en"  # Default to English if detection fails
 
-        translation = translator(
-            text, 
-            src_lang=source_code,   # Pass source language
-            tgt_lang=target_lang    # Pass target language
+def get_homeopathic_advice(symptoms, lang="en"):
+    """Search the web for remedies and generate a professional homeopathic response."""
+    try:
+        response = groq_client.chat.completions.create(
+            model="llama3-70b-8192",
+            messages=[
+                {"role": "system", "content": CHATBOT_ROLE},
+                {"role": "user", "content": f"Find the best homeopathic remedy for: {symptoms}. Provide remedy details, usage, dose, sources, and availability."}
+            ],
+            temperature=0.3
         )
-
-        return translation[0]['translation_text']
-    
+        return response.choices[0].message.content
     except Exception as e:
-        st.error(f"⚠️ Translation error: {str(e)}")
-        return text  # Return original text if translation fails
+        return f"❌ Error fetching homeopathic advice: {str(e)}"
 
-def get_homeopathic_advice(symptoms):
-    """Get medical advice using Groq AI API."""
+def translate_text(text, target_lang):
+    """Translate text using Groq's LLaMA model."""
     try:
         response = groq_client.chat.completions.create(
             model="llama3-70b-8192",
-            messages=[{
-                "role": "user",
-                "content": f"Act as a homeopathic expert. Suggest remedies for: {symptoms}"
-            }],
-            temperature=0.3
+            messages=[
+                {"role": "system", "content": "You are a multilingual AI that accurately translates medical advice while preserving technical accuracy."},
+                {"role": "user", "content": f"Translate this medical advice into {target_lang}: {text}"}
+            ],
+            temperature=0.2
         )
         return response.choices[0].message.content
     except Exception as e:
-        return f"❌ Error fetching homeopathic advice: {str(e)}"
+        return f"⚠️ Translation error: {str(e)}"
 
 # 🎨 Streamlit UI
-st.set_page_config(page_title="Homeo Advisor", page_icon="🌿")
-st.title("🌍 Multilingual Homeopathic Advisor")
+st.set_page_config(page_title="Homeo Doctor AI", page_icon="🌿")
+st.title("🌍 AI-Powered Homeopathic Doctor")
 
-# Chat interface (Persistent session)
+# Chat interface
 if "messages" not in st.session_state:
     st.session_state.messages = []
 
-# Display previous chat messages
+# Display chat history
 for message in st.session_state.messages:
     with st.chat_message(message["role"]):
         st.markdown(message["content"])
 
 # User input box
-if prompt := st.chat_input("Describe symptoms in any language..."):
+if prompt := st.chat_input("Describe your symptoms..."):
     st.session_state.messages.append({"role": "user", "content": prompt})
 
-    with st.spinner("🔍 Analyzing..."):
-        # Translate user input to English
-        english_input = translate_text(prompt, "eng_Latn")
+    with st.spinner("🔍 Analyzing symptoms..."):
+        # Detect user language
+        detected_lang = detect_language(prompt)
 
-        # Get homeopathic advice in English
-        english_advice = get_homeopathic_advice(english_input)
+        # Get homeopathic remedy
+        homeo_advice = get_homeopathic_advice(prompt, detected_lang)
 
-        # Detect original language
-        source_lang = detect(prompt)
-        source_code = LANG_CODE_MAP.get(source_lang, 'eng_Latn')
+        # Translate advice if needed
+        if detected_lang != "en":
+            translated_advice = translate_text(homeo_advice, detected_lang)
+        else:
+            translated_advice = homeo_advice
 
-        # Translate advice back to original language
-        translated_advice = translate_text(english_advice, source_code)
-
-        # Format response
+        # Format final response
         final_response = f"""
-        **💡 English Recommendation:**  
-        {english_advice}  
+        **💡 Expert Homeopathic Advice (English):**  
+        {homeo_advice}  
         
-        **🌍 Translated Recommendation ({source_lang.upper()}):**  
+        **🌍 Translated Advice ({detected_lang.upper()}):**  
         {translated_advice}
         """
 
     # Display response
     with st.chat_message("assistant"):
         st.markdown(final_response)
-    
-    # Save response in session history
+
+    # Save chat history
     st.session_state.messages.append({"role": "assistant", "content": final_response})
 
 # Disclaimer
-st.caption("⚠️ This is not medical advice. Consult a professional.")
+st.caption("⚠️ This AI does not replace professional medical consultation.")