Multilingual

app.py

@@ -31,155 +31,152 @@ SYSTEM = os.getenv("SYSTEM")
 
 # Optional: Set up logging if required for production.
 logging.basicConfig(level=logging.INFO)
+LANGUAGE_DETECTION_PROMPT = os.getenv("Language")
+
+# ---------- Utility Functions ----------
 
 def extract_json_from_response(response):
     message_body = response.text
-
-    # Try to locate code block with triple backticks
     if "```" in message_body:
         start = message_body.find("```")
         end = message_body.find("```", start + 3)
-        
         if end != -1:
-            # Strip optional 'json' or other format specifier
             code_block = message_body[start + 3:end].strip()
             if code_block.startswith("json"):
                 code_block = code_block[4:].strip()
             message_body = code_block
         else:
-            # Only one set of backticks found, possibly malformed
             message_body = message_body[start + 3:].strip()
-    
-    # If there's no backtick block, assume it's plain JSON
+
     try:
         parsed_json = json.loads(message_body)
         logging.info("Parsed JSON: %s", parsed_json)
         return parsed_json
     except json.JSONDecodeError as e:
         logging.error("Failed to parse JSON: %s", e)
-        return None
-    
+        return {}
 
-def translate(message):
+def detect_language(text):
     try:
-        # Request to generate content using the model
         response = client.models.generate_content(
             model="gemini-2.0-flash",
-            config=types.GenerateContentConfig(system_instruction=SYSTEM),
-            contents=message
+            config=types.GenerateContentConfig(system_instruction=LANGUAGE_DETECTION_PROMPT),
+            contents=[{"role": "user", "parts": [{"text": text}]}]
         )
-        
-
-        message_body = extract_json_from_response(response)
+        detected_json = extract_json_from_response(response)
+        return detected_json.get("input_lang", "English")
+    except Exception as e:
+        logging.error(f"Language detection failed: {e}")
+        return "English"
 
-        return message_body
-    
+def translate(content, target_language):
+    try:
+        if not content:
+            return {"translation": ""}
+        response = client.models.generate_content(
+            model="gemini-2.0-flash",
+            config=types.GenerateContentConfig(system_instruction=f"Translate the following content into {target_language}. Respond with plain text only."),
+            contents=[{"role": "user", "parts": [{"text": content}]}]
+        )
+        return extract_json_from_response(response) or {"translation": response.text.strip()}
     except Exception as e:
-        logging.error(f"Error while translating message: {e}")
-        return {}  # Return an empty dict in case of any unexpected errors
+        logging.error(f"Translation failed: {e}")
+        return {"translation": content}
+
+# ---------- Message Generator ----------
 
-def gen_message(data_dict):
-    logging.info(data_dict)
-    if not data_dict['symptoms'] or not data_dict['diseases']:
-        message_body = f"""
-    Hi there, I'm Med-AI-Care, your virtual health assistant.
+def gen_message(data_dict, language="English"):
+    if not data_dict.get("symptoms") or not data_dict.get("diseases"):
+        template = f"""
+Hi there, I'm Med-AI-Care, your virtual health assistant.
 
 I understood your message as:  
-**"{data_dict['translation']}"**
+"{data_dict.get('translation')}"
 
-Thank you for reaching out. Right now, I couldn't detect specific symptoms or conditions based on your message. But you're not alone — it's okay to feel unsure, and I'm still here to support you.
+Thank you for reaching out. I couldn't detect specific symptoms or conditions. It's okay to feel unsure — I'm still here to support you.
 
-**My Analysis**:  
-{data_dict['analysis']}
+My Analysis:  
+{data_dict.get('analysis')}
 
-**Recommendation**:  
-{data_dict['recommendation']}
+Recommendation:  
+{data_dict.get('recommendation')}
 
-I'm an AI assistant, not a doctor. For any health concern, please consult a licensed medical professional.
+Please consult a licensed medical professional for any health concerns.
 
-Take care, and feel free to share more if you'd like me to help further.
-    """.replace("*","")
+Take care!
+"""
     else:
-        message_body = f"""
-    Hi there, I'm Med-AI-Care, your virtual health assistant.
+        symptoms = ', '.join(data_dict.get("symptoms")).capitalize()
+        diseases = '\n'.join([f"- {disease}: {likelihood}" for disease, likelihood in data_dict.get("diseases").items()])
+        template = f"""
+Hi there, I'm Med-AI-Care, your virtual health assistant.
 
 You said:  
-**"{data_dict['translation']}"**
+"{data_dict.get('translation')}"
+
+Symptoms detected:  
+{symptoms}
 
-Here are the symptoms I picked up:  
-**{', '.join(data_dict['symptoms']).capitalize()}**
+Possible conditions:  
+{diseases}
 
-Possible conditions based on your symptoms:  
-{chr(10).join([f"- {disease}: {likelihood}" for disease, likelihood in data_dict['diseases'].items()])}
+My Analysis:  
+{data_dict.get('analysis')}
 
-**My Analysis**:  
-{data_dict['analysis']}
+Recommendation:  
+{data_dict.get('recommendation')}
 
-📝 **Recommendation**:  
-{data_dict['recommendation']}
+I'm not a doctor — please follow up with a healthcare professional.
 
-I'm just an AI helper — not a doctor. Please follow up with a healthcare professional for proper diagnosis and treatment.
+Thanks for reaching out!
+"""
+    if language != "English":
+        translated = translate(template, language)
+        return translated.get("translation", template)
+    return template
 
-Thanks for reaching out. I'm here if you need more help.
-    """.replace("*","")
-        
-        return message_body
+# ---------- Core Chat Function ----------
 
 def chat(cmd):
-    client = Groq(api_key=API_KEY_1)
-    completion = client.chat.completions.create(
+    language = detect_language(cmd)
+
+    client_instance = Groq(api_key=API_KEY_1)
+    completion = client_instance.chat.completions.create(
         model="meta-llama/llama-4-scout-17b-16e-instruct",
         messages=[
-        {
-            "role": "system",
-            "content": TASK
-        },
-        {
-            "role": "user",
-            "content": cmd
-        }
+            {"role": "system", "content": TASK},
+            {"role": "user", "content": cmd}
         ],
         temperature=1,
         max_completion_tokens=1024,
         top_p=1,
         stream=True,
-        stop=None,
     )
 
     output = []
     for chunk in completion:
         output.append(chunk.choices[0].delta.content or "")
 
-
-    in_block = False
+    # Extract JSON from response
     result = ""
-
+    in_block = False
     for line in output:
         if line.strip() == "```":
-            if not in_block:
-                in_block = True
-            else:
-                break
-        elif in_block and line.strip().lower() != "json":
-            result+=line
-
+            in_block = not in_block
+            continue
+        if in_block and line.strip().lower() != "json":
+            result += line
 
     try:
         result_json = json.loads(result)
-        print(result_json)
-        lang = result_json["input_lang"]
-        if lang != "English":
-            data_dict = translate(result)
-            message_body = gen_message(data_dict)
-        else:
-            data_dict = result_json
-            message_body = gen_message(data_dict)
+        data_dict = result_json if language == "English" else translate(result, language)
+        message_body = gen_message(data_dict, language)
     except json.JSONDecodeError as e:
-        print("Failed to parse JSON:", e)
-        output,data_dict,message_body = chat(cmd)
-    
-    return output,data_dict,message_body
+        logging.error("Final JSON parsing failed: %s", e)
+        data_dict = {}
+        message_body = "Sorry, I had trouble understanding your input."
 
+    return output, data_dict, message_body
 
 bot_token = os.getenv("BOT")