Update app.py

app.py

@@ -1,322 +1,121 @@
-import os
 import gradio as gr
+import requests
+import json
 import logging
-import asyncio
+import os
 from dotenv import load_dotenv
-from langchain.prompts import PromptTemplate
-from langchain_qdrant import QdrantVectorStore
-from langchain.chains import RetrievalQA
-from langchain_groq import ChatGroq
-from qdrant_client.models import PointStruct, VectorParams, Distance
-import uuid
-from qdrant_client.http import models
-from datetime import datetime
-from langchain_community.embeddings.fastembed import FastEmbedEmbeddings
-from qdrant_client import QdrantClient
-import cohere
-from langchain.retrievers import ContextualCompressionRetriever
-from langchain_cohere import CohereRerank
-import re
-from translation_service import TranslationService
-
+from typing import Dict, List, Tuple
 # Load environment variables
 load_dotenv()
-
-# Initialize logging with INFO level and detailed format
+# Configure logging
 logging.basicConfig(
-    filename='app.log',
+    filename='gradio_frontend.log',
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s'
 )
 
-# Initialize services
-translator = TranslationService()
-
-def initialize_database_client():
-    """Initialize Qdrant client"""
-    try:
-        client = QdrantClient(
-            url=os.getenv("QDURL"),
-            api_key=os.getenv("API_KEY1"),
-            verify=True # Set to True if using SSL
-        )
-        logging.info("Qdrant client initialized successfully.")
-        return client
-    except Exception as e:
-        logging.error(f"Failed to initialize Qdrant client: {e}")
-        raise
-
-def initialize_llm():
-    """Initialize LLM with fallback"""
-    try:
-        llm = ChatGroq(
-            temperature=0, 
-            model_name="llama3-8b-8192", 
-            api_key=os.getenv("GROQ_API_KEY")
-        )
-        logging.info("ChatGroq initialized with model llama3-8b-8192.")
-        return llm
-    except Exception as e:
-        logging.warning(f"Failed to initialize ChatGroq with llama3: {e}. Falling back to mixtral.")
-        try:
-            llm = ChatGroq(
-                temperature=0, 
-                model_name="mixtral-8x7b-32768", 
-                api_key=os.getenv("GROQ_API_KEY")
-            )
-            logging.info("ChatGroq initialized with fallback model mixtral-8x7b-32768.")
-            return llm
-        except Exception as fallback_e:
-            logging.error(f"Failed to initialize fallback LLM: {fallback_e}")
-            raise
-
-def initialize_services():
-    """Initialize all services"""
+# API Configuration
+API_BASE_URL=os.getenv("API_BASE_URL")
+async def process_query(message: str, language: str, mode: str, chat_history: List[Dict]) -> Tuple[str, str]:
+    """Make API request to get chatbot response"""
     try:
-        # Initialize Qdrant client
-        client = initialize_database_client()
-        
-        # Initialize embeddings
-        embeddings = FastEmbedEmbeddings(model_name="nomic-ai/nomic-embed-text-v1.5-Q")
-        logging.info("FastEmbedEmbeddings initialized successfully.")
-        
-        # Initialize Qdrant DB
-        db = QdrantVectorStore(
-            client=client,
-            embedding=embeddings,
-            collection_name="RR4"
-        )
-        logging.info("QdrantVectorStore initialized with collection 'RR4'.")
+        payload = {
+            "message": message,
+            "language": language,
+            "mode": mode
+        }
         
-        # Initialize retriever with reranker
-        cohere_client = cohere.Client(api_key=os.getenv("COHERE_API_KEY"))
-        reranker = CohereRerank(
-            client=cohere_client,
-            top_n=6,
-            model="rerank-multilingual-v3.0"
-        )
-        base_retriever = db.as_retriever(search_kwargs={"k": 30})
-        retriever = ContextualCompressionRetriever(
-            base_compressor=reranker, 
-            base_retriever=base_retriever
+        response = requests.post(
+            f"{API_BASE_URL}/api/query",
+            json=payload
         )
-        logging.info("Retriever with reranker initialized successfully.")
+        response.raise_for_status()
         
-        # Initialize LLM
-        llm = initialize_llm()
+        result = response.json()
+        return result["answer"], result.get("id")
         
-        return retriever, llm
-    except Exception as e:
-        logging.error(f"Service initialization error: {str(e)}")
-        raise
+    except requests.RequestException as e:
+        logging.error(f"API request failed: {str(e)}")
+        return f"Sorry, there was an error processing your request: {str(e)}", None
 
-def initialize_feedback_collection():
-    """Initialize and verify feedback collection"""
+async def submit_feedback(feedback_type: str, full_chat_history: List[Dict], language_choice: str, mode: str) -> str:
+    """Submit feedback via API"""
     try:
-        client = initialize_database_client()
-        
-        # Check if collection exists
-        collections = client.get_collections().collections
-        collection_exists = any(c.name == "chat_feedback" for c in collections)
-        
-        if not collection_exists:
-            # Create collection with proper configuration
-            client.create_collection(
-                collection_name="chat_feedback",
-                vectors_config=VectorParams(
-                    size=768,  # Ensure this matches the embedding size
-                    distance=Distance.COSINE
-                )
-            )
-            logging.info("Created 'chat_feedback' collection with vector size 768 and Cosine distance.")
-        else:
-            logging.info("'chat_feedback' collection already exists.")
-        
-        # Verify collection exists and has correct configuration
-        collection_info = client.get_collection("chat_feedback")
-        if collection_info.config.params.vectors.size != 768:
-            raise ValueError("Incorrect vector size in 'chat_feedback' collection.")
-        logging.info("'chat_feedback' collection verified successfully with correct vector size.")
-        
-        return True
-    except Exception as e:
-        logging.error(f"Failed to initialize feedback collection: {e}")
-        raise
-
-async def submit_feedback(feedback_type, chat_history, language_choice):
-    """Submit feedback with improved error handling and logging."""
-    try:
-        if not chat_history or len(chat_history) < 2:
-            logging.warning("Attempted to submit feedback with insufficient chat history.")
+        if mode == "Private":
+            return "Feedback is disabled in private mode."
+            
+        if not full_chat_history or len(full_chat_history) < 2:
             return "No recent interaction to provide feedback for."
 
-        # Get last question and answer
-        last_interaction = chat_history[-4:]
-        question = last_interaction[0].get("content", "").strip()
-        answer = last_interaction[1].get("content", "").strip()
-
-        if not question or not answer:
-            logging.warning("Question or answer content is missing.")
-            return "Incomplete interaction data. Cannot submit feedback."
-
-        logging.info(f"Processing feedback for question: {question[:50]}...")
-
-        # Initialize client
-        client = initialize_database_client()
-
-        # Create point ID
-        point_id = str(uuid.uuid4())
-
-        # Create payload
+        # Get the last assistant message with an ID
+        assistant_messages = [msg for msg in full_chat_history 
+                              if msg.get("role") == "assistant" and "id" in msg]
+        
+        if not assistant_messages:
+            logging.error("No assistant messages with ID found in chat history")
+            return "No response found to provide feedback for."
+            
+        last_message = assistant_messages[-1]
+        question_id = last_message.get("id")
+
+        if not question_id:
+            logging.error(f"No ID found in last message: {last_message}")
+            return "Question ID not found. Please try asking another question."
+
+        logging.info(f"Submitting feedback for question ID: {question_id}")
+        
+        # Submit feedback
         payload = {
-            "question": question,
-            "answer": answer,
+            "question_id": question_id,
+            "feedback_type": feedback_type,
             "language": language_choice,
-            "timestamp": datetime.utcnow().isoformat(),
-            "feedback": feedback_type
+            "mode": mode
         }
 
-        # Initialize embeddings
-        embeddings = FastEmbedEmbeddings(model_name="nomic-ai/nomic-embed-text-v1.5-Q")
-
-        # Create embeddings for the Q&A pair
-        try:
-            embedding_text = f"{question} {answer}"
-            vector = await asyncio.to_thread(embeddings.embed_query, embedding_text)
-            logging.info(f"Generated embedding vector of length {len(vector)}.")
-        except Exception as embed_error:
-            logging.error(f"Embedding generation failed: {embed_error}")
-            return "Failed to generate embeddings for your feedback."
-
-        if not isinstance(vector, list) or not vector:
-            logging.error("Invalid vector generated from embeddings.")
-            return "Failed to generate valid embeddings for your feedback."
-
-        # Create point
-        point = PointStruct(
-            id=point_id,
-            payload=payload,
-            vector=vector
-        )
-
-        # Store in Qdrant
-        try:
-            operation_info = await asyncio.to_thread(
-                client.upsert,
-                collection_name="chat_feedback",
-                points=[point]
-            )
-            logging.info(f"Feedback submitted successfully: {point_id}")
-            return "Thanks for your feedback! Your response has been recorded."
-        except Exception as db_error:
-            logging.error(f"Failed to upsert point to Qdrant: {db_error}")
-            return "Sorry, there was an error submitting your feedback."
-
-    except Exception as e:
-        logging.error(f"Unexpected error in submit_feedback: {e}")
-        return "Sorry, there was an unexpected error submitting your feedback."
-
-# Initialize services and feedback collection
-try:
-    retriever, llm = initialize_services()
-    initialize_feedback_collection()
-except Exception as initialization_error:
-    logging.critical(f"Initialization failed: {initialization_error}")
-    raise
-
-# Prompt template
-prompt_template = PromptTemplate(
-    template="""You are RRA Assistant, created by Cedric to help users get tax related information in Rwanda. Your task is to answer tax-related questions using the provided context.
-
-Context: {context}
-
-User's Question: {question}
-
-Please follow these steps to answer the question:
-
-Step 1: Analyze the question
-Briefly explain your understanding of the question and any key points to address. If it is hi or hello, skip to step 3 and respond with a greeting.
-
-Step 2: Provide relevant information
-Using the context provided, give detailed information related to the question. Include specific facts, figures, or explanations from the context.
-
-Step 3: Final answer
-Provide a clear, concise answer to the original question. Start directly with the relevant information, avoiding phrases like "In summary" or "To conclude".
-
-Remember:
-- If you don't know the answer or can't find relevant information in the context, say so honestly.
-- Do not make up information.
-- Use the provided context to support your answer.
-- Include "For more information, call 3004" at the end of every answer.
-
-Your response:
-""",
-    input_variables=['context', 'question']
-)
-
-async def process_query(message: str, language: str, chat_history: list) -> str:
-    try:
-        # Handle translation based on selected language
-        if language == "Kinyarwanda":
-            query = translator.translate(message, "rw", "en")
-            logging.info(f"Translated query to English: {query}")
-        else:
-            query = message
-        
-        # Create QA chain
-        qa = RetrievalQA.from_chain_type(
-            llm=llm,
-            chain_type="stuff",
-            retriever=retriever,
-            chain_type_kwargs={"prompt": prompt_template},
-            return_source_documents=True
-        )
-        
-        # Get response
-        response = await asyncio.to_thread(
-            lambda: qa.invoke({"query": query})
+        response = requests.post(
+            f"{API_BASE_URL}/api/feedback",
+            json=payload
         )
-        logging.info("QA chain invoked successfully.")
+        response.raise_for_status()
         
-        # Extract final answer
-        result_text = response.get('result', '')
-        final_answer_start = result_text.find("Step 3: Final answer")
-        if final_answer_start != -1:
-            answer = result_text[final_answer_start + len("Step 3: Final answer"):].strip()
-        else:
-            answer = result_text
-        
-        # Clean up the answer
-        answer = re.sub(r'\*\*', '', answer).strip()
-        answer = re.sub(r'Step \d+:', '', answer).strip()
-        
-        # Translate response if needed
-        if language == "Kinyarwanda":
-            answer = translator.translate(answer, "en", "rw")
-            logging.info(f"Translated answer to Kinyarwanda: {answer}")
+        return "Thanks for your feedback! Your response has been recorded."
         
-        return answer
+    except requests.RequestException as e:
+        logging.error(f"Failed to submit feedback: {str(e)}")
+        return f"Sorry, there was an error submitting your feedback: {str(e)}"
     except Exception as e:
-        logging.error(f"Query processing error: {str(e)}")
-        return f"An error occurred: {str(e)}"
-
-# Define separate feedback submission functions to pass feedback type correctly
-async def submit_positive_feedback(chat_history, language_choice):
-    return await submit_feedback("positive", chat_history, language_choice)
-
-async def submit_negative_feedback(chat_history, language_choice):
-    return await submit_feedback("negative", chat_history, language_choice)
+        logging.error(f"Unexpected error in submit_feedback: {str(e)}")
+        return "An unexpected error occurred. Please try again."
 
 # Create Gradio interface
 with gr.Blocks(title="RRA FAQ Chatbot") as demo:
+    full_chat_history = gr.State([])  # Add this line
+    
     gr.Markdown(
         """
         # RRA FAQ Chatbot
         Ask tax-related questions in English or Kinyarwanda
-        > 🔒 Your questions and interactions remain private unless you choose to submit feedback, which helps improve our service.
         """
     )
     
+    # Add mode selector
+    with gr.Row():
+        interaction_mode = gr.Radio(
+            choices=["Normal", "Private"],
+            value="Normal",
+            label="Interaction Mode",
+            info="Normal: Stores interactions to improve service | Private: No data storage"
+        )
+    
+    with gr.Row():
+        gr.Markdown(
+            """
+            > 📝 **Data Storage Notice:** 
+            > - Normal Mode: Questions and interactions are stored to improve our service
+            > - Private Mode: No data is stored, feedback feature is disabled
+            """
+        )
+    
     # Add language selector
     language = gr.Radio(
         choices=["English", "Kinyarwanda"],
@@ -327,8 +126,7 @@ with gr.Blocks(title="RRA FAQ Chatbot") as demo:
     chatbot = gr.Chatbot(
         value=[],
         show_label=False,
-        height=400,
-        type='messages'
+        height=400
     )
     
     with gr.Row():
@@ -340,7 +138,8 @@ with gr.Blocks(title="RRA FAQ Chatbot") as demo:
         submit = gr.Button("Send")
     
     # Add feedback section
-    with gr.Row():
+    feedback_container = gr.Row(visible=True)
+    with feedback_container:
         with gr.Column(scale=2):
             feedback_label = gr.Markdown("Was this response helpful?")
         with gr.Column(scale=1):
@@ -351,20 +150,77 @@ with gr.Blocks(title="RRA FAQ Chatbot") as demo:
     # Add feedback status message
     feedback_status = gr.Markdown("")
     
-    # Connect feedback buttons to their respective functions
+    async def respond(message, lang, mode, chat_history, full_chat_history):
+        """Process a user message and update chat history"""
+        try:
+            if chat_history is None:
+                chat_history = []
+            if full_chat_history is None:
+                full_chat_history = []
+
+            # Get response from API
+            bot_message, question_id = await process_query(message, lang, mode, chat_history)
+            if not bot_message:
+                return "", chat_history, full_chat_history
+
+            # Build new messages
+            user_message = {
+                "content": message,
+                "role": "user"
+            }
+            
+            assistant_message = {
+                "content": bot_message,
+                "role": "assistant",
+                "id": question_id  # Store ID in the message
+            }
+
+            # Append to full chat history
+            new_full_history = full_chat_history + [user_message, assistant_message]
+
+            # Prepare messages for chatbot display
+            new_chat_history = chat_history + [[message, bot_message]]
+            return "", new_chat_history, new_full_history
+
+        except Exception as e:
+            logging.error(f"Error in respond function: {e}")
+            return "", chat_history, full_chat_history
+
+    def update_mode(mode: str):
+        """Update UI when mode changes"""
+        is_private = (mode == "Private")
+        return {
+            feedback_container: gr.update(visible=not is_private),
+            feedback_status: gr.update(value="" if not is_private else "Feedback is disabled in private mode")
+        }
+    
+    # Connect feedback buttons
+    async def submit_positive_feedback(full_chat_history, language_choice, mode):
+        return await submit_feedback("positive", full_chat_history, language_choice, mode)
+
+    async def submit_negative_feedback(full_chat_history, language_choice, mode):
+        return await submit_feedback("negative", full_chat_history, language_choice, mode)
+    
     feedback_positive.click(
         fn=submit_positive_feedback,
-        inputs=[chatbot, language],
+        inputs=[full_chat_history, language, interaction_mode],
         outputs=feedback_status
     )
     
     feedback_negative.click(
         fn=submit_negative_feedback,
-        inputs=[chatbot, language],
+        inputs=[full_chat_history, language, interaction_mode],
         outputs=feedback_status
     )
+
+    # Update UI when mode changes
+    interaction_mode.change(
+        fn=update_mode,
+        inputs=[interaction_mode],
+        outputs=[feedback_container, feedback_status]
+    )
     
-    # Create two sets of examples
+    # Example questions
     with gr.Row() as english_examples_row:
         gr.Examples(
             examples=[
@@ -391,12 +247,6 @@ with gr.Blocks(title="RRA FAQ Chatbot") as demo:
             label="Kinyarwanda Examples"
         )
     
-    async def respond(message, lang, chat_history):
-        bot_message = await process_query(message, lang, chat_history)
-        chat_history.append({"role": "user", "content": message})
-        chat_history.append({"role": "assistant", "content": bot_message})
-        return "", chat_history
-    
     def toggle_language_interface(language_choice):
         if language_choice == "English":
             placeholder_text = "Type your tax-related question here..."
@@ -413,10 +263,19 @@ with gr.Blocks(title="RRA FAQ Chatbot") as demo:
                 kinyarwanda_examples_row: gr.update(visible=True)
             }
     
-    msg.submit(respond, [msg, language, chatbot], [msg, chatbot])
-    submit.click(respond, [msg, language, chatbot], [msg, chatbot])
+    # Connect user inputs
+    msg.submit(
+        respond,
+        [msg, language, interaction_mode, chatbot, full_chat_history],
+        [msg, chatbot, full_chat_history]
+    )
+    submit.click(
+        respond,
+        [msg, language, interaction_mode, chatbot, full_chat_history],
+        [msg, chatbot, full_chat_history]
+    )
     
-    # Update both examples visibility and placeholder when language changes
+    # Update interface on language change
     language.change(
         fn=toggle_language_interface,
         inputs=language,
@@ -431,11 +290,9 @@ with gr.Blocks(title="RRA FAQ Chatbot") as demo:
         
         **Disclaimer:** This chatbot provides general tax information. For official guidance, 
         consult RRA or call 3004.
-        🔒 **Privacy:** Your interactions remain private unless you choose to submit feedback.
         """
     )
 
-# Launch the app
 if __name__ == "__main__":
     try:
         demo.launch(share=False)