Update app.py

app.py

@@ -1,4 +1,4 @@
-import subprocess
+import subprocess 
 import os
 import torch
 from dotenv import load_dotenv
@@ -11,7 +11,7 @@ from qdrant_client import QdrantClient, models
 from langchain_openai import ChatOpenAI
 import gradio as gr
 import logging
-from typing import List, Tuple, Generator
+from typing import List, Tuple, Generator, Dict
 from dataclasses import dataclass
 from datetime import datetime
 from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
@@ -22,6 +22,7 @@ from threading import Thread
 from langchain.chains import LLMChain
 from langchain_core.prompts import PromptTemplate
 from langchain_huggingface import HuggingFaceEndpoint
+import json
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -62,30 +63,81 @@ if not HF_TOKEN:
     logger.error("HF_TOKEN is not set in the environment variables.")
     exit(1)
 
-# Query rewriting prompt template
+# Query rewriting prompt template with enhanced reasoning
 query_rewrite_template = """
-Given the chat history and the current question, rewrite the question to be more specific and include relevant context. The rewritten query should help retrieve more accurate information from the Mawared HR knowledge base.
+Given the chat history and the current question, rewrite the question to be more specific and include relevant context. Let's think about this step by step:
 
 Chat History:
 {chat_history}
 
 Current Question: {question}
 
-Instructions:
-1. Analyze the chat history and current question
-2. Identify key concepts and context from previous messages
-3. Incorporate relevant context into the question
-4. Make the question more specific and detailed
-5. Ensure the rewritten question focuses on Mawared HR functionality
+Let's analyze this systematically:
+
+1. First, let's identify the core elements of the question:
+- What is the main topic or action being asked about?
+- What specific Mawared HR features or functions are relevant?
+- What contextual information from chat history might be important?
+
+2. Then, consider any implicit context from the chat history:
+- Are there any previous questions that provide relevant context?
+- Has the user mentioned specific scenarios or requirements before?
+- Are there any unresolved points from previous interactions?
+
+3. Based on this analysis, let's rewrite the question to be more specific and contextual.
 
 Rewritten question:
 """
 
+# Chain of Thought reasoning template
+cot_template = """
+Let's reason through this Mawared HR query step by step to ensure we provide the most accurate and helpful response.
+
+Question: {question}
+Retrieved Context: {context}
+Chat History: {chat_history}
+
+Let's break this down:
+
+1. Question Analysis:
+- What is the core request?
+- What specific Mawared HR functionality is involved?
+- What are the implied requirements?
+
+2. Context Evaluation:
+- What relevant information do we have from the retrieved context?
+- How does this align with the user's question?
+- Are there any gaps in the information?
+
+3. Historical Context:
+- How does the chat history inform this query?
+- Are there any previous interactions that provide additional context?
+- Have similar questions been asked before?
+
+4. Solution Planning:
+- What are the key steps needed to address this query?
+- What specific Mawared HR features should be highlighted?
+- What potential challenges should we address?
+
+Based on this analysis, here's how we should formulate our response:
+
+Reasoning: Let's structure our response to address the user's needs...
+
+{reasoning}
+
+Final Answer: {answer}
+"""
+
 query_rewrite_prompt = PromptTemplate(
     input_variables=["chat_history", "question"],
     template=query_rewrite_template
 )
 
+cot_prompt = PromptTemplate(
+    input_variables=["question", "context", "chat_history", "reasoning", "answer"],
+    template=cot_template
+)
+
 embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
 
 try:
@@ -135,34 +187,33 @@ llm = ChatOpenAI(
     stream=True,
 )
 
-# Create query rewriting chain
+# Create chains
 query_rewrite_chain = LLMChain(
     llm=llm,
     prompt=query_rewrite_prompt,
     verbose=True
 )
 
+cot_chain = LLMChain(
+    llm=llm,
+    prompt=cot_prompt,
+    verbose=True
+)
+
 template = """
-You are a highly specialized AI assistant for the Mawared HR System. Your only function is to provide accurate, detailed, and contextually relevant support based strictly on the information within the provided context and the current chat history.
+You are a highly specialized AI assistant for the Mawared HR System. Your responses should be based on the provided chain of thought reasoning and retrieved context.
+
+Previous Chain of Thought Analysis: {cot_analysis}
+
 Mandatory Principles:
 Source of Truth: You must only use information found in the retrieved context and the ongoing chat. Do not access external knowledge or invent details.
 Clarity and Precision: Communicate with clarity, conciseness, and professional accuracy. Use straightforward language for ease of understanding.
 Actionable Guidance: Focus exclusively on delivering practical solutions, step-by-step workflows, and troubleshooting advice directly related to the user's Mawared HR query.
 Structured Instructions: When appropriate, provide numbered, easy-to-follow instructions to simplify complex processes.
-Targeted Questions for Clarity: If a user's query lacks necessary detail, ask specific, focused clarifying questions to ensure a complete and accurate response. Be specific about the missing information needed.
+Targeted Questions for Clarity: If a user's query lacks necessary detail, ask specific, focused clarifying questions to ensure a complete and accurate response.
 Exclusive Mawared Focus: All responses must pertain solely to the Mawared HR System. Avoid any discussion of unrelated topics.
 Friendly and Professional Tone: Maintain a consistently friendly, approachable, and professional communication style.
-Instructions for Responding:
-Analyze the User's Need: Thoroughly review the user's question and the preceding conversation.
-Consult the Context: Identify the most relevant information within the provided context to directly answer the user's query.
-Provide a Direct and Concise Answer: State your answer clearly and avoid unnecessary jargon or lengthy explanations.
-Support with Details (If Applicable): Include relevant supporting details or step-by-step instructions drawn directly from the context.
-Politely Seek Clarification (When Necessary): If the context lacks sufficient information, politely ask targeted questions to obtain the needed details. Example: "To best assist you with [task/issue], could you please specify [missing information]?"
-Handling Information Gaps:
-If the answer is not explicitly available within the provided context and chat history, state that you require more information to assist them. Do not attempt to answer based on assumptions or external knowledge.
-Critical and Non-Negotiable Constraint:
-STRICTLY adhere to answering ONLY from the provided context and chat history. Do not generate information about Mawared HR that is not explicitly present within these sources.
-Dont mention a Human support contact unless asked for one.
+
 Previous Conversation: {chat_history}
 Retrieved Context: {context}
 Current Question: {question}
@@ -171,12 +222,71 @@ Answer:
 
 prompt = ChatPromptTemplate.from_template(template)
 
-def create_rag_chain(chat_history: str):
+async def perform_chain_of_thought(question: str, context: str, chat_history: str) -> Dict[str, str]:
+    try:
+        # Initial reasoning about the question
+        reasoning = await llm.apredict(
+            f"""
+            Let's think through this Mawared HR query:
+            
+            Question: {question}
+            
+            1. Core Request Analysis:
+            - What specifically is the user asking about?
+            - What Mawared HR components are involved?
+            
+            2. Context Relevance:
+            - How does the provided context relate to the question?
+            - What specific information can we use?
+            
+            3. Solution Formation:
+            - What are the key points we need to address?
+            - What specific steps or information should we provide?
+            
+            Reasoning:
+            """
+        )
+        
+        # Generate initial answer based on reasoning
+        initial_answer = await llm.apredict(
+            f"""
+            Based on the above reasoning and context, provide a detailed answer:
+            
+            {reasoning}
+            
+            Answer:
+            """
+        )
+        
+        # Combine everything in the CoT format
+        cot_analysis = await cot_chain.arun(
+            question=question,
+            context=context,
+            chat_history=chat_history,
+            reasoning=reasoning,
+            answer=initial_answer
+        )
+        
+        return {
+            "reasoning": reasoning,
+            "answer": initial_answer,
+            "cot_analysis": cot_analysis
+        }
+    except Exception as e:
+        logger.error(f"Error in chain of thought reasoning: {e}")
+        return {
+            "reasoning": "Error in reasoning process",
+            "answer": "Unable to complete analysis",
+            "cot_analysis": "Error in chain of thought process"
+        }
+
+def create_rag_chain(chat_history: str, cot_analysis: str):
     chain = (
         {
             "context": retriever,
             "question": RunnablePassthrough(),
-            "chat_history": lambda x: chat_history
+            "chat_history": lambda x: chat_history,
+            "cot_analysis": lambda x: cot_analysis
         }
         | prompt
         | llm
@@ -222,7 +332,16 @@ async def ask_question_gradio(question: str, history: List[List[str]]) -> Genera
         
         # Rewrite the query
         rewritten_question = await rewrite_query(question, formatted_history)
-        rag_chain = create_rag_chain(formatted_history)
+        
+        # Retrieve context
+        context_docs = retriever.get_relevant_documents(rewritten_question)
+        context = "\n".join([doc.page_content for doc in context_docs])
+        
+        # Perform chain of thought reasoning
+        cot_results = await perform_chain_of_thought(rewritten_question, context, formatted_history)
+        
+        # Create RAG chain with CoT analysis
+        rag_chain = create_rag_chain(formatted_history, cot_results["cot_analysis"])
         
         history.append([question, ""])
         
@@ -246,6 +365,12 @@ async def ask_question_gradio(question: str, history: List[List[str]]) -> Genera
         
         chat_history.add_message("assistant", response)
         
+        # Log the reasoning process
+        logger.info("Chain of Thought Analysis:")
+        logger.info(f"Reasoning: {cot_results['reasoning']}")
+        logger.info(f"Initial Answer: {cot_results['answer']}")
+        logger.info(f"Final CoT Analysis: {cot_results['cot_analysis']}")
+        
     except Exception as e:
         logger.error(f"Error during question processing: {e}")
         if not history:
@@ -260,7 +385,7 @@ def clear_chat():
 # Gradio Interface
 with gr.Blocks(theme='Hev832/Applio') as iface:
     gr.Image("Image.jpg", width=750, height=300, show_label=False, show_download_button=False)
-    gr.Markdown("# Mawared HR Assistant 2.7.0 Beta")
+    gr.Markdown("# Mawared HR Assistant 2.6.5")
     gr.Markdown('### Instructions')
     gr.Markdown("Ask a question about MawaredHR and get a detailed answer, if you get an error try again with same prompt, its an Api issue and we are working on it 😀")