Update app.py

app.py

@@ -1,4 +1,4 @@
-import subprocess 
+import subprocess
 import os
 import torch
 from dotenv import load_dotenv
@@ -72,20 +72,6 @@ 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:
 """
 
@@ -96,24 +82,7 @@ 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}
+Reasoning:
 """
 
 response_template = """
@@ -131,12 +100,6 @@ 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:
 """
 
@@ -197,16 +160,18 @@ retriever = db.as_retriever(
 )
 
 # Initialize LLM
-llm = ChatCerebras(
-    model="llama-3.3-70b",
+
+
+llm = ChatOpenAI(
+    model="Qwen/Qwen2.5-72B-Instruct",
     temperature=0,
     max_tokens=None,
     timeout=None,
     max_retries=2,
-    api_key=C_apikey,
+    api_key=HF_TOKEN,
+    base_url="https://api-inference.huggingface.co/v1/",
     stream=True,
 )
-
 # Initialize chains
 query_rewrite_chain = LLMChain(
     llm=llm,
@@ -242,23 +207,17 @@ 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
                 
-            if isinstance(chunk, dict):
-                chunk_text = chunk.get('content', '')
-            else:
-                chunk_text = str(chunk)
-                
+            chunk_text = chunk.get('content', '') if isinstance(chunk, dict) else str(chunk)
             current_response += chunk_text
             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")
@@ -272,8 +231,6 @@ 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}")
@@ -282,119 +239,21 @@ 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 = 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:
-            """
-        )
-        
+        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": "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."
+        return {"reasoning": "", "cot_analysis": ""}
 
 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"""
-    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())
-        
-        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 [], ""
+# The rest remains the same for Gradio components.
 
 # Gradio Interface
 with gr.Blocks(theme='Hev832/Applio') as iface: