app.py

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 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

    # User input section for voice
    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"]

                # 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}")

        # Clear the input field after the query is processed
        st.session_state.user_input = ""  # Reset the input field for next use