Update app.py

app.py

@@ -1,98 +1,174 @@
-import streamlit as st
-import google.generativeai as genai
 import os
-from PIL import Image
-import numpy as np
-from deepface import DeepFace  # Replacing FER with DeepFace
-from dotenv import load_dotenv
-
-# Print out successful imports
-print("DeepFace is installed and ready to use!")
-print("Google Generative AI module is successfully imported!")
-
-# Load API keys and environment variables
-load_dotenv()
-genai.configure(api_key="AIzaSyAEzZLb7R1CNTWwFXoUsWNrV47X9JgGu1o")
-
-# gemini function for general content generation
-def get_gemini_response(input):
-    try:
-        model = genai.GenerativeModel('gemini-pro')
-        response = model.generate_content(input)
-        return response
-    except Exception as e:
-        # Handle quota exceeded error
-        if "RATE_LIMIT_EXCEEDED" in str(e):
-            st.error("Quota exceeded for content generation. Please try again later.")
-            return None
-        else:
-            st.error(f"Error: {e}")
-            return None
-
-# Function to analyze image for depression and emotion detection using DeepFace
-def detect_emotions(image):
-    try:
-        # Convert PIL Image to NumPy array
-        image_array = np.array(image)
-        # Use DeepFace to analyze emotions
-        analysis = DeepFace.analyze(image_array, actions=['emotion'], enforce_detection=False)
-        # Return the dominant emotion and its score
-        return analysis[0]['dominant_emotion'], analysis[0]['emotion']
-    except Exception as e:
-        st.error(f"Error during emotion detection: {e}")
-        return None, None
-
-# Function to analyze detected emotions with LLM
-def analyze_emotions_with_llm(emotion, emotions):
-    emotion_analysis = f"{emotion}: {emotions[emotion]:.2f}"
-    analysis_prompt = f"""
-    ### As a mental health and emotional well-being expert, analyze the following detected emotions.
-    ### Detected Emotions:
-    {emotion_analysis}
-    ### Analysis Output:
-    1. Identify any potential signs of depression based on the detected emotions.
-    2. Explain the reasoning behind your identification.
-    3. Provide recommendations for addressing any identified issues.
-    """
-    response = get_gemini_response(analysis_prompt)
-    return response
-
-# Function to parse and display response content
-def display_response_content(response):
-    st.subheader("Response Output")
-    if response and hasattr(response, 'candidates'):
-        response_content = response.candidates[0].content.parts[0].text if response.candidates[0].content.parts else ""
-        sections = response_content.split('###')
-        for section in sections:
-            if section.strip():
-                section_lines = section.split('\n')
-                section_title = section_lines[0].strip()
-                section_body = '\n'.join(line.strip() for line in section_lines[1:] if line.strip())
-                if section_title:
-                    st.markdown(f"**{section_title}**")
-                if section_body:
-                    st.write(section_body)
-    else:
-        st.write("No response received from the model or quota exceeded.")
-
-# Streamlit App
-st.title("AI-Powered Depression and Emotion Detection System")
-st.text("Use the AI system for detecting depression and emotions from images.")
-
-# Tabs for different functionalities (only image analysis in this version)
-with st.container():
-    st.header("Image Analysis")
-    uploaded_file = st.file_uploader("Upload an image for analysis", type=["jpg", "jpeg", "png"], help="Please upload an image file.")
-    submit_image = st.button('Analyze Image')
-
-    if submit_image:
-        if uploaded_file is not None:
-            image = Image.open(uploaded_file)  # Open the uploaded image
-            emotion, emotions = detect_emotions(image)  # Detect emotions using DeepFace
-            if emotion:  # If emotions are detected
-                response = analyze_emotions_with_llm(emotion, emotions)  # Analyze detected emotions with LLM
-                display_response_content(response)  # Display the analysis response
-            else:
-                st.write("No emotions detected in the image.")  # If no emotion is detected
-        else:
-            st.write("Please upload an image first.")  # Prompt for image upload if none is uploaded
+import json
+import sqlite3
+from datetime import datetime
+import streamlit as st
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_chroma import Chroma
+from langchain_groq import ChatGroq
+from langchain.memory import ConversationBufferMemory
+from langchain.chains import ConversationalRetrievalChain
+from deep_translator import GoogleTranslator
+
+# Directory paths and configurations
+working_dir = os.path.dirname(os.path.abspath(__file__))
+config_data = json.load(open(f"{working_dir}/config.json"))
+GROQ_API_KEY = config_data["GROQ_API_KEY"]
+os.environ["GROQ_API_KEY"] = GROQ_API_KEY
+
+# Set up the database with check_same_thread=False
+def setup_db():
+    conn = sqlite3.connect("chat_history.db", check_same_thread=False)  # Ensure thread-safe connection
+    cursor = conn.cursor()
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS chat_histories (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT,
+            timestamp TEXT,
+            day TEXT,
+            user_message TEXT,
+            assistant_response TEXT
+        )
+    """)
+    conn.commit()
+    return conn  # Return the connection
+
+# Function to save chat history to SQLite
+def save_chat_history(conn, username, timestamp, day, user_message, assistant_response):
+    cursor = conn.cursor()
+    cursor.execute("""
+        INSERT INTO chat_histories (username, timestamp, day, user_message, assistant_response)
+        VALUES (?, ?, ?, ?, ?)
+    """, (username, timestamp, day, user_message, assistant_response))
+    conn.commit()
+
+# Function to set up vectorstore for embeddings
+def setup_vectorstore():
+    embeddings = HuggingFaceEmbeddings()
+    vectorstore = Chroma(persist_directory="vector_db_dir", embedding_function=embeddings)
+    return vectorstore
+
+# Function to set up the chatbot chain
+def chat_chain(vectorstore):
+    llm = ChatGroq(model="llama-3.1-70b-versatile", temperature=0)
+    retriever = vectorstore.as_retriever()
+    memory = ConversationBufferMemory(
+        llm=llm,
+        output_key="answer",
+        memory_key="chat_history",
+        return_messages=True
+    )
+    chain = ConversationalRetrievalChain.from_llm(
+        llm=llm,
+        retriever=retriever,
+        chain_type="stuff",
+        memory=memory,
+        verbose=True,
+        return_source_documents=True
+    )
+    return chain
+
+# Streamlit UI setup
+st.set_page_config(page_title="Bhagavad Gita Query Assistant", page_icon="📚", layout="centered")
+st.title("📚 Bhagavad Gita & Yoga Sutras Query Assistant")
+st.subheader("Ask questions and explore timeless wisdom!")
+
+# Initialize session state
+if "conn" not in st.session_state:
+    st.session_state.conn = setup_db()
+
+if "username" not in st.session_state:
+    username = st.text_input("Enter your name to proceed:")
+    if username:
+        with st.spinner("Loading chatbot interface... Please wait."):
+            st.session_state.username = username
+            st.session_state.chat_history = []  # Initialize empty chat history in memory
+            st.session_state.vectorstore = setup_vectorstore()
+            st.session_state.conversational_chain = chat_chain(st.session_state.vectorstore)
+            st.success(f"Welcome, {username}! The chatbot interface is ready.")
+else:
+    username = st.session_state.username
+
+# Language options (30 Indian languages)
+languages = [
+    "English", "Hindi", "Bengali", "Telugu", "Marathi", "Tamil", "Urdu", "Gujarati", "Malayalam", "Kannada",
+    "Punjabi", "Odia", "Maithili", "Sanskrit", "Santali", "Kashmiri", "Nepali", "Dogri", "Manipuri", "Bodo",
+    "Sindhi", "Assamese", "Konkani", "Maithili", "Awadhi", "Rajasthani", "Haryanvi", "Bihari", "Chhattisgarhi", "Magahi"
+]
+
+# Main interface
+if "username" in st.session_state:
+    st.subheader(f"Hello {username}, start your query below!")
+
+    # Language selection for translation
+    selected_language = st.selectbox("Select the output language", languages, index=languages.index("English"))
+
+    # Input options for the user to type or use voice input
+    input_option = st.radio("Choose Input Method", ("Type your question",))
+
+    # Container to hold the chat interface (for scrolling)
+    chat_container = st.container()
+
+    with chat_container:
+        if "chat_history" in st.session_state:
+            for message in st.session_state.chat_history:
+                if message['role'] == 'user':
+                    with st.chat_message("user"):
+                        st.markdown(message["content"])
+                elif message['role'] == 'assistant':
+                    with st.chat_message("assistant"):
+                        st.markdown(message["content"])
+
+    # User input section for typing
+    user_query = None  # Initialize user_query as None
+
+    if input_option == "Type your question":
+        user_query = st.chat_input("Ask AI about Bhagavad Gita or Yoga Sutras:")  # Chat input for typing
+
+    # If user input is provided, process the query
+    if user_query:
+        with st.spinner("Processing your query... Please wait."):
+
+            # Save user input to chat history in memory
+            st.session_state.chat_history.append({"role": "user", "content": user_query})
+
+            # Display user's message in chatbot (for UI display)
+            with st.chat_message("user"):
+                st.markdown(user_query)
+
+            # Get assistant's response from the chain
+            with st.chat_message("assistant"):
+                response = st.session_state.conversational_chain({"question": user_query})
+                assistant_response = response["answer"]
+
+                # Save assistant's response to chat history in memory
+                st.session_state.chat_history.append({"role": "assistant", "content": assistant_response})
+
+                # Format output in JSON
+                formatted_output = {
+                    "book": "Bhagavad Gita",  # or "PYS" for Yoga Sutras
+                    "chapter_number": "2",  # Example, replace with actual value from response
+                    "verse_number": "47",  # Example, replace with actual value from response
+                    "shloka": "Yoga karmasu kaushalam",  # Example, replace with actual shloka from response
+                    "translation": assistant_response,
+                    "commentary": "This is a commentary on the shloka.",  # Replace with actual commentary
+                    "summary": "This is a summary of the chapter."  # Replace with actual summary
+                }
+
+                # Save the chat history to the database (SQLite)
+                timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                day = datetime.now().strftime("%A")  # Get the day of the week (e.g., Monday)
+                save_chat_history(st.session_state.conn, username, timestamp, day, user_query, assistant_response)
+
+                # Translate the assistant's response based on selected language
+                translator = GoogleTranslator(source="en", target=selected_language.lower())
+                translated_response = translator.translate(assistant_response)
+
+                # Display translated response
+                st.markdown(f"**Translated Answer ({selected_language}):** {translated_response}")
+
+                # Display the formatted output
+                st.json(formatted_output)
+
+        # Clear the input field after the query is processed
+        st.session_state.user_input = ""  # Reset the input field for next use