Update app.py

app.py

@@ -1,8 +1,7 @@
 import streamlit as st
 import streamlit_chat
-import json
 import os
-import datetime
+from datetime import datetime
 from pymongo import MongoClient
 from bson import ObjectId
 from dotenv import load_dotenv
@@ -11,6 +10,10 @@ from langchain_google_genai import GoogleGenerativeAIEmbeddings
 from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_core.prompts import ChatPromptTemplate
 import re
+from pytz import timezone
+from pytz import timezone, utc
+from datetime import datetime
+
 st.set_page_config(layout="wide", page_title="IOCL Chatbot", page_icon="📄")
 load_dotenv()
 import logging
@@ -25,7 +28,7 @@ logging.basicConfig(
 pymongo_logger = logging.getLogger('pymongo')
 pymongo_logger.setLevel(logging.WARNING)
 
-PINECONE_API=os.getenv("PINECONE_API_KEY")
+PINECONE_API = os.getenv("PINECONE_API_KEY")
 pc = pinecone.Pinecone(
     api_key=PINECONE_API
 )
@@ -35,7 +38,7 @@ index = pc.Index(index_name)
 MONGO_URI = os.getenv("MONGO_URI")
 client = MongoClient(MONGO_URI)
 db = client["chatbot_db"]
-chat_sessions = db["chat_sessions3"]
+chat_sessions = db["chat_sessions2"]
 
 # Set LLM models
 FLASH_API = os.getenv("FLASH_API")
@@ -55,8 +58,13 @@ if 'regenerate' not in st.session_state:
 
 # Function to create a new chat session in MongoDB
 def create_new_chat_session():
+    # Get the current time in IST
+    ind_time = datetime.now(timezone("Asia/Kolkata"))
+    # Convert IST time to UTC for storing in MongoDB
+    utc_time = ind_time.astimezone(utc)
+
     new_session = {
-        "created_at": datetime.datetime.utcnow(),
+        "created_at": utc_time,  # Store in UTC
         "messages": []  # Empty at first
     }
     session_id = chat_sessions.insert_one(new_session).inserted_id
@@ -74,11 +82,12 @@ def load_chat_session(session_id):
 
 # Function to update chat session in MongoDB (store last 15 question-answer pairs)
 # Function to update chat session in MongoDB (store entire chat history)
-def update_chat_session(session_id, question, answer,improved_question):
+def update_chat_session(session_id, question, answer, improved_question):
     # Append the new question-answer pair to the full messages array
     chat_sessions.update_one(
         {"_id": ObjectId(session_id)},
-        {"$push": {"messages": {"$each": [{"question": question,'improved_question':improved_question,"answer": answer}]}}}
+        {"$push": {
+            "messages": {"$each": [{"question": question, 'improved_question': improved_question, "answer": answer}]}}}
     )
 
 
@@ -104,7 +113,6 @@ def regenerate_response():
             with st.spinner("Please wait, regenerating the response!"):
                 # Generate a new response for the last question using only the previous history
 
-
                 query = get_context_from_messages(last_question, previous_history)
                 if query:
                     logging.info(f"Extracted query is :{query}\n")
@@ -115,17 +123,39 @@ def regenerate_response():
                         query = last_question
 
                     query_embedding = embeddings.embed_query(query)
-                    search_results = index.query(vector=query_embedding, top_k=5, include_metadata=True)
-                    matches = search_results['matches']
+                    # Step 1: Fetch top 5 chunks based on similarity
+                    search_results = index.query(vector=query_embedding, top_k=10, include_metadata=True)
+                    matches = search_results.get('matches', [])
+
+                    # Step 2: Use the tag from the first chunk (if available)
+                    first_chunk_tag = matches[0]['metadata'].get('tag', None) if matches else None
+
+                    # Decision logic based on the first chunk's tag
+                    if first_chunk_tag:
+                        # Use the first chunk's tag to filter and retrieve all relevant chunks
+                        all_chunks_response = index.query(
+                            vector=query_embedding,
+                            filter={"tag": first_chunk_tag},
+                            top_k=15,  # Adjust top_k as needed
+                            include_metadata=True
+                        )
+                        all_chunks = all_chunks_response.get('matches', [])
+                    else:
+                        # If the first chunk has no tag, pass the top 5 chunks as they are
+                        all_chunks = matches
 
-                    content = ""
-                    for i, match in enumerate(matches):
-                        chunk = match['metadata']['chunk']
-                        url = match['metadata']['url']
-                        content += f"chunk{i}: {chunk}\n" + f"url{i}: {url}\n"
+                    # Check if `all_chunks` has any content before iterating
+                    if all_chunks:
+                        content = ""
+                        for i, match in enumerate(all_chunks):
+                            chunk = match['metadata']['chunk']
+                            url = match['metadata']['url']
+                            content += f"chunk{i}: {chunk}\n" + f"Reference url{i}: {url}\n"
 
-                    new_reply= generate_summary(content, query, previous_history)
+                    else:
+                        st.warning("No relevant chunks found for this query. Please try a different question.")
 
+                    new_reply = generate_summary(content, query, previous_history)
 
                     st.session_state['chat_history'][-1]["answer"] = new_reply
 
@@ -140,33 +170,31 @@ def regenerate_response():
         st.error("Error occured in Regenerating response, please try again later.")
 
 
-
-
+# When generating a response, pass only the latest 15 messages to the LLM
 def generate_summary(chunks, query, chat_history):
     try:
-        # Limit the history sent to the LLM to the latest 3 question-answer pairs
-        limited_history = chat_history[-3:] if len(chat_history) > 3 else chat_history
+        # Limit the history sent to the LLM to the latest 15 question-answer pairs
+        limited_history = chat_history[-5:] if len(chat_history) > 5 else chat_history
 
         # Create conversation history for the LLM, only using the last 15 entries
         history_text = "\n".join([f"User: {q['improved_question']}\nLLM: {q['answer']}" for q in limited_history])
 
         # Define the system and user prompts including the limited history
         prompt = ChatPromptTemplate.from_messages([
-            ("system", """You are a chatbot specializing in answering queries related to Indian Oil Corporation Limited (IOCL). You will be provided with chunks of data from the IOCL website to answer user queries. Each chunk will include associated URLs, You must give the url of the chunks which you are using to answer the query.
+            ("system", """You are a chatbot specializing in answering queries related to Indian Oil Corporation Limited (IOCL). You will be provided with chunks of data from the IOCL website to answer user queries. Each chunk will include associated URLs, which you must reference in your responses to show the source of the information.
                             Key Guidelines:
 
-                            1.If the user query is not clear, or you think multiple answers are possbile, you should ask for clarification with proper reasoning.
-                            2.Do not mention chunk name in any of your replies.
+                            1.If the user query is not clear, or you think multiple answers are possbile, you can ask for clarification with proper reasoning. Do not mention chunk name in any of your replies.
                             2.Detailed and Clear: Provide thorough, clear, and concise responses without omitting relevant information from the data chunks.
                             3.Natural Summarization: When answering, you must not  directly quote chunk names,formats. Instead, summarize or interpret the data naturally and conversationally.
                             4.Use Conversation History: Refer back to the conversation history to maintain consistency and build on prior responses, if applicable.
-                            5.Ignore Unanswered Queries: If the conversation history contains previous responses like "The answer is not available in the context," disregard them when formulating your current response.
+                            5.Ignore Unanswered Queries: If the conversation history contains previous responses like cannot answer, information not present disregard them when formulating your current response.
                             6.Graceful Handling of General Queries: If a user sends greetings, introduction, salutations, or unrelated questions, respond appropriately and conversationally.
                             7.Include Source URLs: Always include the URLs from the relevant chunks of data that you're using to answer the query.
                             8.Thoroughly looks for answer to the query in the provided chunks before replying, if you feel the query is irrelevant or answer is not present then you can ask user to clarify or tell that it cannot be answered.
-                            9.Sometimes chunks might contain very less data still use it if its relevant.
 
-                            """),
+
+                                          """),
 
             ("human", f'''
                             "Query":\n {query}\n
@@ -191,12 +219,13 @@ def generate_summary(chunks, query, chat_history):
         st.error(f"Error answering your question: {e}")
         return None
 
+
 def get_context_from_messages(query, chat_history):
     try:
 
         logging.info(f"Getting context from original query: {query}")
 
-        # Limit the history sent to the LLM to the latest 3 question-answer pairs
+        # Limit the history sent to the LLM to the latest 15 question-answer pairs
         limited_history = chat_history[-3:] if len(chat_history) > 3 else chat_history
 
         # Create conversation history for the LLM, only using the last 15 entries
@@ -204,11 +233,14 @@ def get_context_from_messages(query, chat_history):
 
         # Define the system and user prompts including the limited history
         prompt = ChatPromptTemplate.from_messages([
-            ("system", """"I will provide you with a user query and up to the last 3 messages from the chat history which includes both questions and answers.Your task is to understand  the user query nicely and restructure it if required such that  it  makes complete sense and is completely self contained.
+            ("system", """"I will provide you with a user query and up to the last 3 messages from the chat history, including both questions and answers.Your task is to reformulate the user query nicely which makes complete sense and is completely self contained.
                            The provided queries are related to Indian Oil Corporation limited (IOCL).
                            1. If the query is a follow-up, use the provided chat history to reconstruct a well-defined, contextually complete query that can stand alone."
-                           2. if the query is self contained, if applicable try to improve it to make is coherent.
+                           2. if the query is self contained, if applicable try to improve it to make it coherent.
                            3. if the user query is salutations, greetings or not relevant in that case give the query back as it is.
+                           4. Even if the user query is just a one word query, you must formulate a well defined query.
+                           5. Its not necessary to always use the chat history, sometimes a query will be self sufficient all it would need is improvement in language
+                           
                            I have provided an output format below, stricly follow it. Do not give anything else other than just the output.
                            expected_output_format: "query: String or None"
                            """),
@@ -253,10 +285,13 @@ if st.sidebar.button("New Chat"):
 existing_sessions = chat_sessions.find().sort("created_at", -1)
 for session in existing_sessions:
     session_id = str(session['_id'])
-    session_date = session['created_at'].strftime("%Y-%m-%d %H:%M:%S")
-    col1, col2 = st.sidebar.columns([8, 1])
 
-    # Display session name
+    # Retrieve stored UTC time and convert it to IST for display
+    utc_time = session['created_at']
+    ist_time = utc_time.replace(tzinfo=utc).astimezone(timezone("Asia/Kolkata"))
+    session_date = ist_time.strftime("%Y-%m-%d %H:%M:%S")  # Format for display
+
+    col1, col2 = st.sidebar.columns([8, 1])
     with col1:
         if st.button(f"Session {session_date}", key=session_id):
             st.session_state['current_chat_id'] = session_id
@@ -283,41 +318,66 @@ if user_question:
 
     with st.spinner("Please wait, I am thinking!!"):
         # Store the user's question and get the assistant's response
-        query=get_context_from_messages(user_question,st.session_state['chat_history'])
+        query = get_context_from_messages(user_question, st.session_state['chat_history'])
         if query:
             logging.info(f"Extracted query is :{query}\n")
-            extracted_query=get_query_from_llm_answer(query)
+            extracted_query = get_query_from_llm_answer(query)
             if extracted_query:
-                query=extracted_query
+                query = extracted_query
             else:
-                query=user_question
-
-            query_embedding=embeddings.embed_query(query)
-            search_results = index.query(vector=query_embedding, top_k=15, include_metadata=True)
-            matches=search_results['matches']
-
-            content=""
-            for i,match in enumerate(matches):
-                chunk=match['metadata']['chunk']
-                url=match['metadata']['url']
-                content += f"chunk{i}: {chunk}\n" + f"url{i}: {url}\n"
-
-
-            print(f"content being passed is {content}")
-            reply = generate_summary(content, query, st.session_state['chat_history'])
+                query = user_question
+
+            query_embedding = embeddings.embed_query(query)
+            # Retrieve top 10 chunks based on similarity
+            search_results = index.query(vector=query_embedding, top_k=10, include_metadata=True)
+            matches = search_results.get('matches', [])
+
+            # Use the tag from the first chunk if available
+            first_chunk_tag = matches[0]['metadata'].get('tag', None) if matches else None
+
+            # Decision logic based on the first chunk's tag
+            if first_chunk_tag:
+                # Use the first chunk's tag to filter and retrieve all relevant chunks
+                all_chunks_response = index.query(
+                    vector=query_embedding,
+                    filter={"tag": first_chunk_tag},
+                    top_k=15,  # Adjust as needed
+                    include_metadata=True
+                )
+                all_chunks = all_chunks_response.get('matches', [])
+            else:
+                # If the first chunk has no tag, pass the top 10 chunks as they are
+                all_chunks = matches
+
+            # Check if `all_chunks` has any content before iterating
+            if all_chunks:
+                # Prepare content for the LLM using metadata from each chunk
+                content = ""
+                for i, match in enumerate(all_chunks):
+                    chunk = match['metadata'].get('chunk', '')
+                    url = match['metadata'].get('url', '')
+                    content += f"chunk{i}: {chunk}\nReference url{i}: {url}\n"
+
+                # Generate the summary using the LLM
+                print(f"content being sent is {content}")
+                reply = generate_summary(content, query, st.session_state['chat_history'])
+            else:
+                st.warning("No relevant chunks found for this query. Please try a different question.")
+                reply = None  # Ensure `reply` is defined even if `all_chunks` is empty
 
+            # Display or handle the reply if generated successfully
             if reply:
                 # Append the new question-answer pair to chat history
-                st.session_state['chat_history'].append({"question": user_question, "answer": reply,"improved_question":query})
+                st.session_state['chat_history'].append(
+                    {"question": user_question, "answer": reply, "improved_question": query}
+                )
 
                 # Update the current chat session in MongoDB
                 if st.session_state['current_chat_id']:
-                    update_chat_session(st.session_state['current_chat_id'], user_question, reply,query)
-
+                    update_chat_session(st.session_state['current_chat_id'], user_question, reply, query)
             else:
-                st.error("Error processing your request, Please try again later.")
-        else:
-            st.error("Error processing your request, Please try again later.")
+                st.error("Error processing your request. Please try again later.")
+
 # Display the updated chat history (show last 15 question-answer pairs)
 for i, pair in enumerate(st.session_state['chat_history']):
     question = pair["question"]