Upload 4 files

app.py

@@ -0,0 +1,547 @@
+# import os
+# import json
+# import streamlit as st
+# from langchain_huggingface import HuggingFaceEmbeddings
+# from langchain_chroma import Chroma
+# from langchain.memory import ConversationBufferMemory
+# from langchain.chains import ConversationalRetrievalChain
+# from vectorize_documents import embeddings
+# import speech_recognition as sr
+# import sounddevice as sd
+# import numpy as np
+# from scipy.io.wavfile import write
+# from deep_translator import GoogleTranslator
+
+# # Set up working directory and API configuration
+# working_dir = os.path.dirname(os.path.abspath(__file__))
+# config_data = json.load(open(f"{working_dir}/config.json"))
+# os.environ["GROQ_API_KEY"] = config_data["GROQ_API_KEY"]
+
+# # Streamlit session state initialization
+# def initialize_session_state():
+#     if "chat_history" not in st.session_state:
+#         st.session_state["chat_history"] = []
+#     if "vectorstore" not in st.session_state:
+#         st.session_state["vectorstore"] = setup_vectorstore()
+#     if "chain" not in st.session_state:
+#         st.session_state["chain"] = chat_chain(st.session_state["vectorstore"])
+
+# # Vectorstore setup
+# def setup_vectorstore():
+#     embeddings = HuggingFaceEmbeddings()
+#     vectorstore = Chroma(
+#         persist_directory=f"{working_dir}/vector_db_dir",
+#         embedding_function=embeddings
+#     )
+#     return vectorstore
+
+# # Chat chain setup with logging
+# def chat_chain(vectorstore):
+#     from langchain_groq import ChatGroq
+#     llm = ChatGroq(
+#         model="llama-3.1-70b-versatile",
+#         temperature=0
+#     )
+#     retriever = vectorstore.as_retriever()
+#     memory = ConversationBufferMemory(
+#         memory_key="chat_history",
+#         return_messages=True
+#     )
+#     chain = ConversationalRetrievalChain.from_llm(
+#         llm=llm,
+#         retriever=retriever,
+#         chain_type="stuff",
+#         memory=memory,
+#         verbose=True  # Enables debugging logs
+#     )
+#     return chain
+
+# # Transcription function with SoundDevice
+# def transcribe_audio(selected_language):
+#     try:
+#         duration = 5  # seconds
+#         samplerate = 44100  # Hz
+#         st.write("🎤 Listening... Please ask your question.")
+#         recording = sd.rec(int(duration * samplerate), samplerate=samplerate, channels=1, dtype='int16')
+#         sd.wait()
+#         audio_path = "/tmp/temp_audio.wav"
+#         write(audio_path, samplerate, recording)
+
+#         recognizer = sr.Recognizer()
+#         with sr.AudioFile(audio_path) as source:
+#             audio = recognizer.record(source)
+#             query = recognizer.recognize_google(audio, language=selected_language)
+#             st.write(f"**🗣️ You said:** {query}")
+#             return query
+#     except sr.WaitTimeoutError:
+#         st.error("⏳ You didn't speak in time. Please try again.")
+#     except sr.UnknownValueError:
+#         st.error("❌ Sorry, could not understand the audio. Please try again.")
+#     except sr.RequestError as e:
+#         st.error(f"⚠️ Error with speech recognition service: {e}")
+#     except Exception as e:
+#         st.error(f"⚠️ Audio input error: {str(e)}")
+#     return None
+
+# # Translation functions
+# def translate_to_english(text, source_lang):
+#     if source_lang == "en":
+#         return text
+#     return GoogleTranslator(source=source_lang, target="en").translate(text)
+
+# def translate_from_english(text, target_lang):
+#     if target_lang == "en":
+#         return text
+#     return GoogleTranslator(source="en", target=target_lang).translate(text)
+
+# # Streamlit UI
+# initialize_session_state()
+
+# st.markdown(
+#     """
+#     <style>
+#     .main-title {
+#         font-size: 36px;
+#         color: #FF8C00;
+#         font-weight: bold;
+#     }
+#     .sub-title {
+#         font-size: 24px;
+#         color: #FF8C00;
+#     }
+#     .icon {
+#         font-size: 50px;
+#         color: #FF8C00;
+#     }
+#     </style>
+#     """,
+#     unsafe_allow_html=True
+# )
+
+# st.markdown('<div class="icon">📚</div>', unsafe_allow_html=True)
+# st.markdown('<div class="main-title">Bhagavad Gita & Yoga Sutras Query Assistant</div>', unsafe_allow_html=True)
+# st.markdown('<div class="sub-title">Ask questions and explore timeless wisdom</div>', unsafe_allow_html=True)
+
+# # Language support
+# indian_languages = {
+#     "English": "en",
+#     "Assamese": "as",
+#     "Bengali": "bn",
+#     "Gujarati": "gu",
+#     "Hindi": "hi",
+#     "Kannada": "kn",
+#     "Kashmiri": "ks",
+#     "Konkani": "kok",
+#     "Malayalam": "ml",
+#     "Manipuri": "mni",
+#     "Marathi": "mr",
+#     "Nepali": "ne",
+#     "Odia": "or",
+#     "Punjabi": "pa",
+#     "Sanskrit": "sa",
+#     "Santali": "sat",
+#     "Sindhi": "sd",
+#     "Tamil": "ta",
+#     "Telugu": "te",
+#     "Urdu": "ur",
+#     "Bodo": "brx",
+#     "Dogri": "doi",
+#     "Maithili": "mai",
+#     "Santhali": "sat",
+#     "Tulu": "tcy",
+#     "Bhili/Bhilodi": "bhi",
+#     "Khasi": "kha",
+#     "Garo": "grt",
+#     "Mizo": "lus",
+#     "Sora": "srb",
+#     "Ho": "hoc",
+#     "Kurukh": "kru",
+#     "Korwa": "kfa",
+#     "Gondi": "gon",
+#     "Konkani": "kok"
+# }
+
+# selected_language = st.selectbox("Select your language:", options=list(indian_languages.keys()))
+# language_code = indian_languages[selected_language]
+
+# # User-friendly input selection
+# st.markdown("### How would you like to ask your question?")
+# input_mode = st.radio("Choose input method:", ("Voice", "Typing"))
+
+# user_query = None
+
+# if input_mode == "Voice":
+#     st.write("Click the button below to speak your question:")
+#     if st.button("🎤 Use Voice Input"):
+#         user_query = transcribe_audio(language_code)
+#         if user_query:
+#             user_query = translate_to_english(user_query, language_code)
+# else:
+#     user_query = st.text_input("Type your question here:")
+#     if user_query:
+#         user_query = translate_to_english(user_query, language_code)
+
+# # Handle user query
+# if user_query:
+#     with st.spinner("Getting answer..."):
+#         try:
+#             response = st.session_state["chain"]({"question": user_query})
+
+#             # Debug retrieved context and chain response
+#             relevant_content = response.get("source_documents", None)
+#             st.write("Debug Info: Retrieved Context", relevant_content)
+
+#             if relevant_content:
+#                 st.markdown("### ✅ **Answer:**")
+#                 answer = response.get("answer", "No answer generated.")
+#                 st.write(answer)
+#         except Exception as e:
+#             st.error(f"⚠️ An error occurred: {str(e)}")
+
+
+# import os
+# 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 vectorize_documents import embeddings
+
+# 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
+# # Streamlit 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!")
+
+# # Step 1: Initialize the connection and check if the user is already logged in
+# 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
+
+# # Step 2: Initialize components if not already set
+# if "conversational_chain" not in st.session_state:
+#     st.session_state.vectorstore = setup_vectorstore()
+#     st.session_state.conversational_chain = chat_chain(st.session_state.vectorstore)
+
+# # Step 3: Display the chat history in the UI
+# if "username" in st.session_state:
+#     st.subheader(f"Hello {username}, start your query below!")
+
+#     # Display chat history (messages exchanged between user and assistant)
+#     if st.session_state.chat_history:
+#         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"])
+
+#     # Input field for the user to type their message
+#     user_input = st.chat_input("Ask AI....")
+    
+#     if user_input:
+#         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_input})
+
+#             # Display user's message in chatbot (for UI display)
+#             with st.chat_message("user"):
+#                 st.markdown(user_input)
+
+#             # Get assistant's response from the chain
+#             with st.chat_message("assistant"):
+#                 response = st.session_state.conversational_chain({"question": user_input})
+#                 assistant_response = response["answer"]
+#                 st.markdown(assistant_response)
+
+#                 # Save assistant's response to chat history in memory
+#                 st.session_state.chat_history.append({"role": "assistant", "content": assistant_response})
+
+#                 # 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_input, assistant_response)
+
+
+import os
+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
+import speech_recognition as sr
+
+# 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
+
+# Function to get audio input from the user
+def get_audio_input():
+    recognizer = sr.Recognizer()
+    with sr.Microphone() as source:
+        print("🎤 Listening... Please ask your question.")
+        try:
+            audio = recognizer.listen(source, timeout=5)
+            query = recognizer.recognize_google(audio)
+            print(f"You said: {query}")
+            return query
+        except sr.WaitTimeoutError:
+            print("⏳ You didn't speak in time. Please try again.")
+        except sr.UnknownValueError:
+            print("❌ Sorry, could not understand the audio. Please try again.")
+        except sr.RequestError as e:
+            print(f"⚠️ Error with speech recognition service: {e}")
+    return ""
+
+# 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
+
+# Initialize components if not already set
+if "conversational_chain" not in st.session_state:
+    st.session_state.vectorstore = setup_vectorstore()
+    st.session_state.conversational_chain = chat_chain(st.session_state.vectorstore)
+
+# 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", "Ask via Voice"))
+
+    # 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"])
+
+    # Keep the chat interface scrollable
+    st.markdown(
+        """
+        <style>
+        .streamlit-expanderHeader {
+            display: none;
+        }
+        .chat-container {
+            max-height: 400px;
+            overflow-y: scroll;
+        }
+        </style>
+        """,
+        unsafe_allow_html=True
+    )
+
+    # User input section at the bottom
+    user_query = None  # Initialize user_query as None
+
+    if input_option == "Type your question":
+        user_query = st.text_input("Ask AI about Bhagavad Gita or Yoga Sutras:")
+    elif input_option == "Ask via Voice":
+        if st.button("🎤 Ask via Voice"):
+            with st.spinner("Listening for your question..."):
+                user_query = get_audio_input()
+
+    # 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"]
+
+                # If no relevant content found, return a default response
+                if not response.get("source_documents"):
+                    assistant_response = "I don't have enough information to answer this question from the Bhagavad Gita or Yoga Sutras."
+
+                # Display the assistant's answer
+                st.markdown(assistant_response)
+
+                # Save assistant's response to chat history in memory
+                st.session_state.chat_history.append({"role": "assistant", "content": assistant_response})
+
+                # 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}")

config.json

@@ -0,0 +1 @@
+{"GROQ_API_KEY": "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"}

requirements.txt

@@ -0,0 +1,13 @@
+streamlit==1.38.0
+langchain-community==0.2.16
+langchain-text-splitters==0.2.4
+langchain-chroma==0.1.3
+langchain-huggingface==0.0.3
+langchain-groq==0.1.9
+unstructured==0.15.0
+nltk==3.8.1
+docx2txt
+SpeechRecognition
+deep-translator
+sounddevice  # Replacement for PyAudio
+scipy  # Required for WAV file handling with SoundDevice