Update app.py

app.py

@@ -1,4 +1,4 @@
-import subprocess 
+import subprocess
 import os
 import torch
 from dotenv import load_dotenv
@@ -11,19 +11,13 @@ from qdrant_client import QdrantClient, models
 from langchain_openai import ChatOpenAI
 import gradio as gr
 import logging
-from typing import List, Tuple, Generator, Dict, AsyncGenerator
+from typing import List, Tuple, Generator
 from dataclasses import dataclass
 from datetime import datetime
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-from langchain_huggingface.llms import HuggingFacePipeline
-from langchain_cerebras import ChatCerebras
 from queue import Queue
 from threading import Thread
 from langchain.chains import LLMChain
 from langchain_core.prompts import PromptTemplate
-from langchain_huggingface import HuggingFaceEndpoint
-import json
-import asyncio
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -57,120 +51,51 @@ class ChatHistory:
 load_dotenv()
 
 HF_TOKEN = os.getenv("HF_TOKEN")
-C_apikey = os.getenv("C_apikey")
+QDRANT_URL = os.getenv("QDRANT_URL")
+QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
 
 if not HF_TOKEN:
     logger.error("HF_TOKEN is not set in the environment variables.")
     exit(1)
 
-# Templates
+# Query rewriting prompt template
 query_rewrite_template = """
-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:
+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.
 
 Chat History:
 {chat_history}
 
 Current Question: {question}
 
-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.
+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
 
 Rewritten question:
 """
 
-cot_template = """
-Let's reason through this Mawared HR query step by step:
-
-Question: {question}
-Retrieved Context: {context}
-Chat History: {chat_history}
-
-1. Understanding the Query:
-- Core Request: What is the user trying to achieve?
-- System Components: Which Mawared HR modules are involved?
-- User Context: What do we know about the user's situation?
-
-2. Analyzing Available Information:
-- Relevant Context: What specific information from our knowledge base applies?
-- Historical Context: How does the chat history inform this query?
-- Information Gaps: What additional details might we need?
-
-3. Solution Formulation:
-- Key Steps: What actions are needed to address this query?
-- Potential Challenges: What issues should we anticipate?
-- Additional Considerations: What else should the user know?
-
-Based on this analysis, let's structure our response to be clear, accurate, and helpful.
-
-Reasoning: {reasoning}
-"""
-
-response_template = """
-You are a highly specialized AI assistant for the Mawared HR System. Base your response on the following analysis and context:
-
-Chain of Thought Analysis:
-{cot_analysis}
-
-Context Information:
-{context}
-
-Chat History:
-{chat_history}
-
-Current Question:
-{question}
-
-Please provide a clear, structured response that:
-1. Directly addresses the user's question
-2. Includes specific steps or instructions where relevant
-3. Maintains a professional yet friendly tone
-4. References only information from the provided context
-
-Response:
-"""
-
-# Initialize prompt templates
 query_rewrite_prompt = PromptTemplate(
     input_variables=["chat_history", "question"],
     template=query_rewrite_template
 )
 
-cot_prompt = PromptTemplate(
-    input_variables=["question", "context", "chat_history", "reasoning"],
-    template=cot_template
-)
-
-response_prompt = PromptTemplate(
-    input_variables=["cot_analysis", "context", "chat_history", "question"],
-    template=response_template
-)
-
-# Initialize embeddings and Qdrant
 embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
 
 try:
     client = QdrantClient(
-        url=os.getenv("QDRANT_URL"),
-        api_key=os.getenv("QDRANT_API_KEY"),
+        url=QDRANT_URL,
+        api_key=QDRANT_API_KEY,
         prefer_grpc=False
     )
 except Exception as e:
-    logger.error(f"Failed to connect to Qdrant: {e}")
+    logger.error("Failed to connect to Qdrant.")
     exit(1)
 
-# Setup collection
 collection_name = "mawared"
+
 try:
     client.create_collection(
         collection_name=collection_name,
@@ -184,7 +109,6 @@ except Exception as e:
         logger.error(f"Error creating collection: {e}")
         exit(1)
 
-# Initialize vector store and retriever
 db = Qdrant(
     client=client,
     collection_name=collection_name,
@@ -196,7 +120,6 @@ retriever = db.as_retriever(
     search_kwargs={"k": 5}
 )
 
-# Initialize LLM
 llm = ChatOpenAI(
     model="Qwen/Qwen2.5-72B-Instruct",
     temperature=0,
@@ -208,64 +131,72 @@ llm = ChatOpenAI(
     stream=True,
 )
 
-# Initialize chains
+# Create query rewriting chain
 query_rewrite_chain = LLMChain(
     llm=llm,
     prompt=query_rewrite_prompt,
     verbose=True
 )
 
-cot_chain = LLMChain(
-    llm=llm,
-    prompt=cot_prompt,
-    verbose=True
-)
+# Updated Prompt Template with Chain-of-Thought Reasoning
+reasoning_prompt_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.
+Your answer should include step-by-step reasoning (chain of thought) to explain your logic clearly and guide the user effectively.
 
-response_chain = LLMChain(
-    llm=llm,
-    prompt=response_prompt,
-    verbose=True
-)
+Mandatory Principles:
+- **Source of Truth**: Use only information found in the retrieved context and chat history.
+- **Clarity and Precision**: Communicate in a clear, concise, and professional manner.
+- **Actionable Guidance**: Provide practical solutions, step-by-step workflows, and troubleshooting advice.
+- **Structured Reasoning**: Include numbered, logical steps to explain your reasoning.
 
-async def astream_processor(chain, inputs: dict) -> AsyncGenerator[str, None]:
-    """Process streaming responses asynchronously"""
-    try:
-        async for chunk in chain.astream(inputs):
-            if isinstance(chunk, dict):
-                content = chunk.get('content', '')
-            elif hasattr(chunk, 'model_dump'):
-                # If the chunk has a model_dump method, convert it to a dictionary and get the content
-                content = chunk.model_dump().get('content', '')
-            else:
-                content = str(chunk)
-            yield content
-    except Exception as e:
-        logger.error(f"Error in stream processing: {e}")
-        yield ""
+Instructions for Responding:
+1. Start by analyzing the user's query and the retrieved context.
+2. Use step-by-step reasoning to answer the query in detail.
+3. Conclude with a concise summary of the solution.
+
+Chat History:
+{chat_history}
+
+Retrieved Context:
+{context}
 
-async def process_stream_async(stream_queue: asyncio.Queue, history: List[List[str]]) -> AsyncGenerator[List[List[str]], None]:
-    """Handle streaming response processing"""
+Current Question:
+{question}
+
+Answer with detailed reasoning:
+"""
+
+reasoning_prompt = ChatPromptTemplate.from_template(reasoning_prompt_template)
+
+def create_rag_chain(chat_history: str):
+    chain = (
+        {
+            "context": retriever,
+            "question": RunnablePassthrough(),
+            "chat_history": lambda x: chat_history
+        }
+        | reasoning_prompt
+        | llm
+        | StrOutputParser()
+    )
+    return chain
+
+chat_history = ChatHistory()
+
+def process_stream(stream_queue: Queue, history: List[List[str]]) -> Generator[List[List[str]], None, None]:
     current_response = ""
     
-    try:
-        while True:
-            chunk = await stream_queue.get()
-            if chunk is None:
-                break
-                
-            current_response += chunk
-            new_history = history.copy()
-            new_history[-1][1] = current_response
-            yield new_history
+    while True:
+        chunk = stream_queue.get()
+        if chunk is None:
+            break
             
-            stream_queue.task_done()
-    except asyncio.CancelledError:
-        logger.info("Stream processing cancelled")
-    except Exception as e:
-        logger.error(f"Error in stream processing: {e}")
+        current_response += chunk
+        new_history = history.copy()
+        new_history[-1][1] = current_response
+        yield new_history
 
 async def rewrite_query(question: str, formatted_history: str) -> str:
-    """Rewrite the query for better context understanding"""
     try:
         rewritten_question = await query_rewrite_chain.arun(
             question=question,
@@ -278,71 +209,7 @@ async def rewrite_query(question: str, formatted_history: str) -> str:
         logger.error(f"Error in query rewriting: {e}")
         return question
 
-async def perform_chain_of_thought(question: str, context: str, chat_history: str) -> Dict[str, str]:
-    """Execute chain of thought reasoning"""
-    try:
-        reasoning = await llm.invoke(
-            f"""
-            Let's think through this Mawared HR query:
-            
-            Question: {question}
-            Context: {context}
-            
-            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:
-            """
-        )
-        
-        cot_analysis = await cot_chain.arun(
-            question=question,
-            context=context,
-            chat_history=chat_history,
-            reasoning=reasoning
-        )
-        
-        return {
-            "reasoning": reasoning,
-            "cot_analysis": cot_analysis
-        }
-    except Exception as e:
-        logger.error(f"Error in chain of thought reasoning: {e}")
-        return {
-            "reasoning": "Error in reasoning process",
-            "cot_analysis": "Error in chain of thought process"
-        }
-
-async def generate_streaming_response(question: str, context: str, chat_history: str, cot_analysis: str) -> AsyncGenerator[str, None]:
-    """Generate streaming response using all available context"""
-    try:
-        inputs = {
-            "question": question,
-            "context": context,
-            "chat_history": chat_history,
-            "cot_analysis": cot_analysis
-        }
-        
-        async for chunk in astream_processor(response_chain, inputs):
-            if chunk:
-                yield chunk
-    except Exception as e:
-        logger.error(f"Error in response generation: {e}")
-        yield "I apologize, but I encountered an error while generating the response."
-
-chat_history = ChatHistory()
-
-async def ask_question_gradio(question: str, history: List[List[str]]) -> AsyncGenerator[tuple, None]:
-    """Main function to handle questions and generate responses"""
+def ask_question_gradio(question: str, history: List[List[str]]) -> Generator[tuple, None, None]:
     try:
         if history is None:
             history = []
@@ -350,34 +217,27 @@ async def ask_question_gradio(question: str, history: List[List[str]]) -> AsyncG
         chat_history.add_message("user", question)
         formatted_history = chat_history.get_formatted_history()
         
+        # Rewrite the query
         rewritten_question = await rewrite_query(question, formatted_history)
-        context_docs = await asyncio.to_thread(retriever.get_relevant_documents, rewritten_question)
-        context = "\n".join([doc.page_content for doc in context_docs])
-        
-        cot_results = await perform_chain_of_thought(rewritten_question, context, formatted_history)
+        rag_chain = create_rag_chain(formatted_history)
         
         history.append([question, ""])
-        stream_queue = asyncio.Queue()
         
-        async def stream_manager():
+        stream_queue = Queue()
+        
+        def stream_processor():
             try:
-                async for chunk in generate_streaming_response(
-                    rewritten_question,
-                    context,
-                    formatted_history,
-                    cot_results["cot_analysis"]
-                ):
-                    if chunk:
-                        await stream_queue.put(chunk)
-                await stream_queue.put(None)
+                for chunk in rag_chain.stream(rewritten_question):
+                    stream_queue.put(chunk)
+                stream_queue.put(None)
             except Exception as e:
                 logger.error(f"Streaming error: {e}")
-                await stream_queue.put(None)
+                stream_queue.put(None)
         
-        asyncio.create_task(stream_manager())
+        Thread(target=stream_processor).start()
         
         response = ""
-        async for updated_history in process_stream_async(stream_queue, history):
+        for updated_history in process_stream(stream_queue, history):
             response = updated_history[-1][1]
             yield "", updated_history
         
@@ -385,37 +245,21 @@ async def ask_question_gradio(question: str, history: List[List[str]]) -> AsyncG
         
     except Exception as e:
         logger.error(f"Error during question processing: {e}")
-        logger.exception("Detailed error:")
         if not history:
             history = []
         history.append([question, "An error occurred. Please try again later."])
         yield "", history
 
 def clear_chat():
-    """Clear chat history"""
     chat_history.clear()
     return [], ""
 
 # 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.1 Early Beta")
-    gr.Markdown('### Patch Notes')
-    gr.Markdown("""
-    1-Fixed Api Issues.
-    
-    2-Better Search Algorithm 
-    
-    3-Now when asked a question, Agent will rewrite the question to enhance it based on its context and user intent and sentiment analysis.
-    
-    4-It will use chain-of-thought reasoning to break down the question to many sub-Questions to answer them better and easier.
-    
-    5-Model is prone to mistakes and hallucinations.
-    
-    WARNING: MODEL IS HIGHLY INTELLIGENT AND IS PRONE TO OVERTHINKING, ANXIETY, TEXT LOOP AND SELF DOUBT.
-    IF THAT HAPPENS PLEASE REPORT IT.
-    Lastly, happy bugging :] .
-    """)
+    gr.Markdown("# Mawared HR Assistant 2.7")
+    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.")
     
     chatbot = gr.Chatbot(
         height=750,