Update app.py

app.py

@@ -1,109 +1,93 @@
 import os
 import json
-import rasa
-import whisper
-from fastapi import FastAPI, UploadFile, File, HTTPException
-from transformers import pipeline
-from geopy.geocoders import Nominatim
-from pymongo import MongoClient
-import streamlit as st
-import os
-os.system("pip install --no-cache-dir -r requirements.txt")
-
+import time
+import speech_recognition as sr
+import pyttsx3
+from transformers import pipeline, AutoTokenizer, AutoModel
 
-# Initialize FastAPI
-app = FastAPI()
+# Initialize Text-to-Speech (TTS)
+tts_engine = pyttsx3.init()
+tts_engine.setProperty("rate", 150)  # Adjust speaking speed
 
-# Load Whisper for Speech-to-Text
-try:
-    whisper_model = whisper.load_model("base")
-except Exception as e:
-    raise RuntimeError(f"Error loading Whisper model: {e}")
+def speak(text):
+    """Convert text to speech."""
+    tts_engine.say(text)
+    tts_engine.runAndWait()
 
-def speech_to_text(audio_path):
-    try:
-        result = whisper_model.transcribe(audio_path)
-        return result["text"]
-    except Exception as e:
-        return f"Error in speech-to-text conversion: {e}"
-
-# Load Medical LLM (PubMedBERT)
-try:
-    medical_llm = pipeline("question-answering", model="nlp4health/pubmedbert")
-except Exception as e:
-    raise RuntimeError(f"Error loading Medical LLM: {e}")
+# Initialize Speech Recognition (STT)
+recognizer = sr.Recognizer()
 
-def analyze_symptoms(question, context):
+def listen():
+    """Capture user's voice input and convert to text."""
+    with sr.Microphone() as source:
+        print("🎤 Listening...")
+        recognizer.adjust_for_ambient_noise(source)
+        audio = recognizer.listen(source)
+    
     try:
-        return medical_llm(question=question, context=context)["answer"]
-    except Exception as e:
-        return f"Error analyzing symptoms: {e}"
+        user_input = recognizer.recognize_google(audio)
+        print(f"User: {user_input}")
+        return user_input
+    except sr.UnknownValueError:
+        speak("Sorry, I didn't catch that. Can you repeat?")
+        return listen()
+    except sr.RequestError:
+        speak("There was an error with the speech recognition service.")
+        return ""
 
-# Connect to MongoDB (Hospital Database)
+# Load Medical Model
 try:
-    client = MongoClient("mongodb://localhost:27017/")
-    db = client["hospital_db"]
-    hospitals = db["hospitals"]
+    tokenizer = AutoTokenizer.from_pretrained("microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract-fulltext")
+    model = AutoModel.from_pretrained("microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract-fulltext")
+    medical_pipeline = pipeline('feature-extraction', model=model, tokenizer=tokenizer, device=-1)
 except Exception as e:
-    raise RuntimeError(f"Error connecting to MongoDB: {e}")
-
-def find_nearby_hospitals(location):
-    try:
-        geolocator = Nominatim(user_agent="geoapi")
-        loc = geolocator.geocode(location)
-        query = {"location": {"$near": {"$geometry": {"type": "Point", "coordinates": [loc.longitude, loc.latitude]}, "$maxDistance": 5000}}}
-        return list(hospitals.find(query))
-    except Exception as e:
-        return f"Error finding hospitals: {e}"
+    speak("Error loading medical AI model. Using fallback response.")
+    medical_pipeline = None
 
 # Store conversation in JSON
-conversations = {}
+conversation_data = {"user_info": {}, "medical_history": [], "chat": []}
 
-def store_conversation(user_id, message, response):
-    try:
-        if user_id not in conversations:
-            conversations[user_id] = []
-        conversations[user_id].append({"user": message, "bot": response})
-        with open("conversations.json", "w") as f:
-            json.dump(conversations, f, indent=4)
-    except Exception as e:
-        return f"Error storing conversation: {e}"
+def save_conversation():
+    with open("conversation.json", "w") as f:
+        json.dump(conversation_data, f, indent=4)
 
-# Streamlit UI
-def streamlit_interface():
-    st.title("Medical Triage Bot")
-    uploaded_file = st.file_uploader("Upload Voice Message", type=["wav", "mp3", "m4a"])
-    if uploaded_file is not None:
-        audio_path = "temp_audio.wav"
-        with open(audio_path, "wb") as f:
-            f.write(uploaded_file.read())
-        text_input = speech_to_text(audio_path)
-        response = analyze_symptoms(text_input, "Common medical symptoms database")
-        store_conversation("guest", text_input, response)
-        st.write(f"**User:** {text_input}")
-        st.write(f"**Bot:** {response}")
+# Collect Basic User Info
+speak("Hello! I am your medical assistant. May I know your name?")
+user_name = listen()
+conversation_data["user_info"]["name"] = user_name
 
-# FastAPI Endpoints
-@app.post("/voice_input/")
-async def process_audio(file: UploadFile = File(...), user_id: str = "guest"):
-    try:
-        audio_path = f"temp_{user_id}.wav"
-        with open(audio_path, "wb") as buffer:
-            buffer.write(await file.read())
-        
-        text_input = speech_to_text(audio_path)
-        response = analyze_symptoms(text_input, "Common medical symptoms database")
-        store_conversation(user_id, text_input, response)
-        return {"user": text_input, "bot": response}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error processing audio: {e}")
+speak(f"Nice to meet you, {user_name}. How old are you?")
+age = listen()
+conversation_data["user_info"]["age"] = age
 
-@app.get("/get_hospitals/")
-def get_hospitals(location: str):
-    try:
-        return find_nearby_hospitals(location)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error fetching hospitals: {e}")
+speak("What is your primary health concern today?")
+health_issue = listen()
+conversation_data["medical_history"].append(health_issue)
+
+# Real-Time Conversation Loop
+while True:
+    speak("Tell me more about your symptoms or concerns.")
+    user_query = listen()
+    
+    if "stop" in user_query.lower() or "bye" in user_query.lower():
+        speak("Thank you for sharing your details. Take care!")
+        break
+    
+    conversation_data["chat"].append({"user": user_query})
+    
+    # Process Medical Query
+    if medical_pipeline:
+        try:
+            embeddings = medical_pipeline(user_query)
+            response = "Based on medical analysis, I recommend consulting a doctor for further evaluation."
+        except Exception:
+            response = "I couldn't analyze your query, but I suggest seeking medical advice."
+    else:
+        response = "I can assist with basic health guidance. Please consult a medical professional for proper diagnosis."
+    
+    conversation_data["chat"].append({"bot": response})
+    speak(response)
+    save_conversation()
 
-if __name__ == "__main__":
-    streamlit_interface()
+# Save final conversation
+save_conversation()