Update app.py

app.py

@@ -1,4 +1,4 @@
-import subprocess
+import subprocess 
 import os
 import torch
 from dotenv import load_dotenv
@@ -72,6 +72,20 @@ 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.
+
 Rewritten question:
 """
 
@@ -82,7 +96,24 @@ Question: {question}
 Retrieved Context: {context}
 Chat History: {chat_history}
 
-Reasoning:
+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 = """
@@ -100,6 +131,12 @@ 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:
 """
 
@@ -160,8 +197,6 @@ retriever = db.as_retriever(
 )
 
 # Initialize LLM
-
-
 llm = ChatOpenAI(
     model="Qwen/Qwen2.5-72B-Instruct",
     temperature=0,
@@ -172,6 +207,7 @@ llm = ChatOpenAI(
     base_url="https://api-inference.huggingface.co/v1/",
     stream=True,
 )
+
 # Initialize chains
 query_rewrite_chain = LLMChain(
     llm=llm,
@@ -197,9 +233,9 @@ async def astream_processor(chain, inputs: dict) -> AsyncGenerator[str, None]:
         async for chunk in chain.astream(inputs):
             if isinstance(chunk, dict):
                 content = chunk.get('content', '')
-                yield content
             else:
-                yield str(chunk)
+                content = str(chunk)
+            yield content
     except Exception as e:
         logger.error(f"Error in stream processing: {e}")
         yield ""
@@ -207,17 +243,18 @@ async def astream_processor(chain, inputs: dict) -> AsyncGenerator[str, None]:
 async def process_stream_async(stream_queue: asyncio.Queue, history: List[List[str]]) -> AsyncGenerator[List[List[str]], None]:
     """Handle streaming response processing"""
     current_response = ""
+    
     try:
         while True:
             chunk = await stream_queue.get()
             if chunk is None:
                 break
                 
-            chunk_text = chunk.get('content', '') if isinstance(chunk, dict) else str(chunk)
-            current_response += chunk_text
+            current_response += chunk
             new_history = history.copy()
             new_history[-1][1] = current_response
             yield new_history
+            
             stream_queue.task_done()
     except asyncio.CancelledError:
         logger.info("Stream processing cancelled")
@@ -231,6 +268,8 @@ async def rewrite_query(question: str, formatted_history: str) -> str:
             question=question,
             chat_history=formatted_history
         )
+        logger.info(f"Original question: {question}")
+        logger.info(f"Rewritten question: {rewritten_question}")
         return rewritten_question.strip()
     except Exception as e:
         logger.error(f"Error in query rewriting: {e}")
@@ -239,21 +278,120 @@ async def rewrite_query(question: str, formatted_history: str) -> str:
 async def perform_chain_of_thought(question: str, context: str, chat_history: str) -> Dict[str, str]:
     """Execute chain of thought reasoning"""
     try:
-        reasoning = "..."
+        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}
+        
+        return {
+            "reasoning": reasoning,
+            "cot_analysis": cot_analysis
+        }
     except Exception as e:
         logger.error(f"Error in chain of thought reasoning: {e}")
-        return {"reasoning": "", "cot_analysis": ""}
+        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()
 
-# The rest remains the same for Gradio components.
+async def ask_question_gradio(question: str, history: List[List[str]]) -> AsyncGenerator[tuple, None]:
+    """Main function to handle questions and generate responses"""
+    try:
+        if history is None:
+            history = []
+            
+        chat_history.add_message("user", question)
+        formatted_history = chat_history.get_formatted_history()
+        
+        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)
+        
+        history.append([question, ""])
+        stream_queue = asyncio.Queue()
+        
+        async def stream_manager():
+            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)
+            except Exception as e:
+                logger.error(f"Streaming error: {e}")
+                await stream_queue.put(None)
+        
+        asyncio.create_task(stream_manager())
+        
+        response = ""
+        async for updated_history in process_stream_async(stream_queue, history):
+            response = updated_history[-1][1]
+            yield "", updated_history
+        
+        chat_history.add_message("assistant", response)
+        
+    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: