changed logic, included RAG

app.py

@@ -6,13 +6,31 @@ import datetime
 from pymongo import MongoClient
 from bson import ObjectId
 from dotenv import load_dotenv
+import pinecone
 from langchain_google_genai import GoogleGenerativeAIEmbeddings
 from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_core.prompts import ChatPromptTemplate
-
+import re
 st.set_page_config(layout="wide", page_title="IOCL Chatbot", page_icon="📄")
 load_dotenv()
-
+import logging
+
+logging.basicConfig(
+    level=logging.DEBUG,  # This is for your application logs
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+
+# Suppress pymongo debug logs by setting the pymongo logger to a higher level
+pymongo_logger = logging.getLogger('pymongo')
+pymongo_logger.setLevel(logging.WARNING)
+
+PINECONE_API=os.getenv("PINECONE_API_KEY")
+pc = pinecone.Pinecone(
+    api_key=PINECONE_API
+)
+index_name = "iocl"
+index = pc.Index(index_name)
 # MongoDB connection setup
 MONGO_URI = os.getenv("MONGO_URI")
 client = MongoClient(MONGO_URI)
@@ -25,9 +43,6 @@ embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001", google_a
 llm = ChatGoogleGenerativeAI(model="gemini-1.5-flash", temperature=0, max_tokens=None, google_api_key=FLASH_API)
 
 # Load the extracted JSON data
-with open('iocl_extracted_2.json', 'r') as file:
-    extracted_data = json.load(file)
-reference_data = json.dumps(extracted_data)
 
 # Initialize session state for current chat session
 if 'current_chat_id' not in st.session_state:
@@ -57,14 +72,13 @@ def load_chat_session(session_id):
         st.session_state['chat_history'] = session['messages']
 
 
-
 # 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):
+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, "answer": answer}]}}}
+        {"$push": {"messages": {"$each": [{"question": question,'improved_question':improved_question,"answer": answer}]}}}
     )
 
 
@@ -78,78 +92,146 @@ def replace_last_response_in_mongo(session_id, new_answer):
             {"$set": {f"messages.{last_message_index}.answer": new_answer}}
         )
 
+
 # Function to regenerate the response
 def regenerate_response():
-    if st.session_state['chat_history']:
-        last_question = st.session_state['chat_history'][-1]["question"]  # Get the last question
-        # Exclude the last response from the history when sending the question to LLM
-        previous_history = st.session_state['chat_history'][:-1]  # Exclude the last Q&A pair
+    try:
+        if st.session_state['chat_history']:
+            last_question = st.session_state['chat_history'][-1]["question"]  # Get the last question
+            # Exclude the last response from the history when sending the question to LLM
+            previous_history = st.session_state['chat_history'][:-1]  # Exclude the last Q&A pair
+
+            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")
+                    extracted_query = get_query_from_llm_answer(query)
+                    if extracted_query:
+                        query = extracted_query
+                    else:
+                        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']
+
+                    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"
+
+                    new_reply= generate_summary(content, query, previous_history)
 
-        with st.spinner("Please wait, regenerating the response!"):
-            # Generate a new response for the last question using only the previous history
-            new_reply = generate_summary(str(reference_data), last_question, previous_history)
 
-        # Replace the last response in the session state with the new reply
-        st.session_state['chat_history'][-1]["answer"] = new_reply
+                    st.session_state['chat_history'][-1]["answer"] = new_reply
 
-        # Update MongoDB with the new response
-        if st.session_state['current_chat_id']:
-            replace_last_response_in_mongo(st.session_state['current_chat_id'], new_reply)
+                    # Update MongoDB with the new response
+                    if st.session_state['current_chat_id']:
+                        replace_last_response_in_mongo(st.session_state['current_chat_id'], new_reply)
 
-        st.session_state['regenerate'] = False  # Reset regenerate flag
-        st.rerun()
+                    st.session_state['regenerate'] = False  # Reset regenerate flag
+                    st.rerun()
+
+    except Exception as e:
+        st.error("Error occured in Regenerating response, please try again later.")
 
 
-# Function to generate a detailed response based on the query and JSON data
 
 
 # When generating a response, pass only the latest 15 messages to the LLM
-def generate_summary(reference_data, query, chat_history):
+def generate_summary(chunks, query, chat_history):
     try:
-        # Escape curly braces in the JSON data to avoid conflicts with prompt placeholders
-        escaped_reference_data = reference_data.replace("{", "{{").replace("}", "}}")
-
         # Limit the history sent to the LLM to the latest 15 question-answer pairs
-        limited_history = chat_history[-15:] if len(chat_history) > 15 else chat_history
+        limited_history = chat_history[-10:] if len(chat_history) > 10 else chat_history
 
         # Create conversation history for the LLM, only using the last 15 entries
-        history_text = "\n".join([f"User: {q['question']}\nLLM: {q['answer']}" for q in limited_history])
+        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 who specialises in answering questions related to Indan Oil Corporation Limitied(IOCL).
-                            This is the extracted data from the Indian Oil Corporation Limited (IOCL) website. The extracted data contains detailed information about the company and its various operations. You will be provided with a query, and you must use this data to answer it comprehensively.
-                            Additionally, the conversation history may contain relevant context or prior queries and responses. Use this history to ensure your answer is accurate and coherent, building on previous information if necessary.
-                          
+            ("system", """You are a chatbot who specialises in answering user queries related to Indan Oil Corporation Limitied(IOCL).
+                            this is the extracted chunks of data from the Indian Oil Corporation Limited (IOCL) website. You will be provided with a query, and you must use these chunks of data to answer it comprehensively.
+                            Each chunk of data has website source page urls associated to it, you must include these relevant urls in your answer telling the source.
+                            Additionally, the conversation history is also provided which may contain relevant context or prior queries and responses. Use this history to ensure your answer is accurate and coherent, building on previous information if necessary.
+
                             Key Guidelines:
                             1.Accuracy is paramount: If the extracted data or conversation history does not contain the information required to answer the query, clearly state, "The answer is not available in the context." Do not attempt to provide a speculative or incorrect response.
                             2.Be detailed: Provide clear, concise, and thorough answers without omitting any relevant information from the extracted data.
                             3.Avoid quoting field names: When responding, avoid directly quoting or referencing field names or formats from the extracted data. Instead, present the information naturally, as if summarizing or interpreting the data. Try to give the answer in points.
                             4.Use the conversation history: When applicable, refer to earlier parts of the conversation to ensure consistency and accuracy in your response.
-                            5.Sometime a query might be a followup question,without proper context in that case try using previous conversation history and try to utilise latest messages to answer it if possible.
                             6.Answer the queries in conversational style.
-                            7.Important - If any links or source PDFs links are available within the extracted data part which you are referring to answer the query, you must include that links in your responses, suggesting that users can refer to the links for more detailed information.
+                            7.It is must to include urls present in the chunk which you are using to formulate your ansewer.
                                           """),
             ("human", f'''
+                            Previous Conversation History: \n{history_text}\n
+                            "Extracted Data": \n{chunks}\n
                             "Query":\n {query}\n
-                            "Previous Conversation History": \n{history_text}\n
-                            "Extracted Data": \n{escaped_reference_data}\n
-                            
                             '''
              )
         ])
 
         # Chain the prompt with LLM for response generation
         chain = prompt | llm
-        result = chain.invoke({"Extracted Data": escaped_reference_data, "Query": query})
+        result = chain.invoke({"Previous Concversation History":history_text,"Extracted Data": chunks, "Query": query})
 
         # Return the generated response
+        logging.info(f"LLM answer is :{result}")
         return result.content
 
     except Exception as e:
         st.error(f"Error answering your question: {e}")
-        return "Error answering question."
+        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 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
+        history_text = "\n".join([f"User: {q['question']}\nLLM: {q['answer']}" for q in limited_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, including both questions and answers. Your task is to determine whether the provided user query is self-contained (i.e., it can be answered directly without relying on prior messages) or a follow-up query that depends on the previous context.
+                           1. If the query is self-contained, return None
+                           2. If the query is a follow-up, use the provided chat history to reconstruct a well-defined, contextually complete query that can stand alone."
+                           
+                           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"
+                           """),
+            ("human", f'''  
+                            "Query":\n {query}\n
+                            Previous Conversation History: \n{history_text}\n
+                            '''
+             )
+        ])
+
+        # Chain the prompt with LLM for response generation
+        chain = prompt | llm
+        result = chain.invoke({"Query": query,"Previous Conversation History":history_text})
+        logging.info(f"llm answer for query extraction is :{result}")
+
+        # Return the generated response
+        return result.content
+
+    except Exception as e:
+        logging.error(f"exception occured in getting query from original query :{e}")
+        return None
+
+def get_query_from_llm_answer(llm_output):
+    match = re.search(r'query:\s*(.*)', llm_output)
+    if match:
+        query = match.group(1).strip().strip('"')  # Remove leading/trailing spaces and quotes
+        return None if query.lower() == "none" else query
+    return None
 
 
 # Sidebar for showing chat sessions and creating new sessions
@@ -195,16 +277,41 @@ if user_question:
 
     with st.spinner("Please wait, I am thinking!!"):
         # Store the user's question and get the assistant's response
-        reply = generate_summary(str(reference_data), 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)
+            if extracted_query:
+                query=extracted_query
+            else:
+                query=user_question
+
+            query_embedding=embeddings.embed_query(query)
+            search_results = index.query(vector=query_embedding, top_k=5, 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"
+
+
 
+            reply = generate_summary(content, query, st.session_state['chat_history'])
 
-    # Append the new question-answer pair to chat history
-        st.session_state['chat_history'].append({"question": user_question, "answer": reply})
+            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})
 
-        # 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)
+                # 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)
 
+            else:
+                st.error("Error processing your request, Please try again later.")
+        else:
+            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"]