Update app.py

app.py

@@ -1,104 +1,106 @@
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import JSONResponse
-from starlette.middleware.cors import CORSMiddleware
-import rasa.core.interpreter
-from rasa.core.agent import Agent
-import asyncio
-import json
 import os
-from dotenv import load_dotenv
+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 requests
-
-load_dotenv()
 
+# Initialize FastAPI
 app = FastAPI()
 
-# CORS setup to allow Streamlit frontend to communicate with FastAPI backend
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Allows all origins (for development, restrict in production)
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Rasa model directory and paths - adjust if needed, or use environment variables
-RASA_MODEL_PATH = os.getenv("RASA_MODEL_PATH", "./models")
-DOMAIN_PATH = os.getenv("DOMAIN_PATH", "./domain.yml")
-NLU_MODEL_PATH = os.getenv("NLU_MODEL_PATH", None) # NLU model path is optional
-
-# Load Rasa agent
-async def load_rasa_agent():
-    interpreter = None
-    if NLU_MODEL_PATH:
-        interpreter = await rasa.core.interpreter.create_interpreter(NLU_MODEL_PATH)
-
-    agent = Agent.load(RASA_MODEL_PATH,
-                       interpreter=interpreter,
-                       domain=DOMAIN_PATH)
-    return agent
-
-loop = asyncio.get_event_loop()
-rasa_agent = loop.run_until_complete(load_rasa_agent())
-
-# FastAPI endpoint for chat
-@app.post("/chat")
-async def chat_endpoint(message_data: dict):
-    """Rasa chatbot endpoint that takes message in JSON and returns bot response."""
-    user_message = message_data.get('message')
-
-    if not user_message:
-        raise HTTPException(status_code=400, detail="Message text not found")
-
-    response = await rasa_agent.handle_text(user_message)
-
-    bot_responses = []
-    for message in response:
-        if "text" in message:
-            bot_responses.append(message["text"])
-
-    return JSONResponse({"responses": bot_responses})
-
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint for monitoring."""
-    return JSONResponse({"status": "ok"})
+# 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 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}")
+
+def analyze_symptoms(question, context):
+    try:
+        return medical_llm(question=question, context=context)["answer"]
+    except Exception as e:
+        return f"Error analyzing symptoms: {e}"
+
+# Connect to MongoDB (Hospital Database)
+try:
+    client = MongoClient("mongodb://localhost:27017/")
+    db = client["hospital_db"]
+    hospitals = db["hospitals"]
+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}"
+
+# Store conversation in JSON
+conversations = {}
+
+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}"
 
 # Streamlit UI
-def main():
-    st.title("HealthVoice Bot")
-    st.write("Talk to the bot about your symptoms.")
-
-    user_input = st.text_input("Your message:", "")
-
-    if user_input:
-        api_url = "http://localhost:8000/chat"  # FastAPI endpoint URL
-        message_payload = {"message": user_input}
-
-        try:
-            response = requests.post(api_url, json=message_payload)
-            response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
-            bot_response_json = response.json()
-            bot_messages = bot_response_json.get("responses", [])
-            for bot_message in bot_messages:
-                st.text_area("Bot Response:", value=bot_message, height=len(bot_message.split('\n')) * 25) # Adjust height dynamically
-
-        except requests.exceptions.RequestException as e:
-            st.error(f"Error communicating with the chatbot backend: {e}")
-
+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}")
+
+# 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}")
+
+@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}")
 
 if __name__ == "__main__":
-    import uvicorn
-    import threading
-
-    # Start FastAPI app in a separate thread
-    def run_fastapi():
-        uvicorn.run(app, host="0.0.0.0", port=8000)
-
-    fastapi_thread = threading.Thread(target=run_fastapi)
-    fastapi_thread.daemon = True # Daemon threads are abruptly stopped at exit
-    fastapi_thread.start()
-
-    main() # Run Streamlit app in the main thread
+    streamlit_interface()