Update app.py

app.py

@@ -1,105 +1,109 @@
 import os
 import json
+import logging
 import gradio as gr
-from utils.response_manager import ResponseManager  # Import the ResponseManager class 
-"""
-This script sets up a Gradio interface to host an AI chatbot using RAG (Retrieval-Augmented Generation)
-to provide responses to user queries. Response API from OpenAI is used for both retrieval and generation of responses.
-"""
-
-# Vector store ID for the retrieval of knowledge base documents
-# Load the vector store ID from the environment variable
-vector_store_id = os.getenv('VECTOR_STORE_ID')
-
-# Check if the VECTOR_STORE_ID environment variable is set
-if not vector_store_id:
-    raise ValueError("VECTOR_STORE_ID environment variable is not set.")
-
-# Initialize the ResponseManager with the vector store ID
-response_manager = ResponseManager(vector_store_id)
-
-# Define the chatbot function to handle user queries and generate responses
-def chat_interaction(query: str, history):
-    """
-    Function to handle the chatbot interaction and maintain conversation history.
-    :param query: The user query to respond to.
-    :param history: The conversation history (list of [input, output] pairs).
-    :return: Updated conversation history.
-    """
-    try:
-        if query.strip():
-            response = response_manager.create_response(query, model, temperature, max_output_tokens, max_num_results)
-            if not response:
-                response = "Sorry, I couldn't generate a response at this time. Please try again later."
-            # Append the conversation
-            history.append((query, response))
-        else:
-            history.append((query, "Please enter a valid query."))
-        return history
-    except Exception as e:
-        history.append((query, str(e)))
-        return history
-        
-# Set parameters for the response generation
-model = "gpt-4o-mini" # Set the model to be used for response generation
-temperature=0  # Set the temperature for response generation 
-max_output_tokens=800  # Set the maximum number of output tokens
-max_num_results=7 # Set the maximum number of knowledge base documents to return for retrieval
-
-# Load the configuration for Gradio GUI interface from the JSON file
-with open('config/gradio_config.json', 'r') as config_file:
-    config = json.load(config_file)
-# Check if the configuration file is loaded successfully
-if not config:
-    raise ValueError("Failed to load the configuration file.")
-# Extract the configuration parameters
-chatbot_title = config["chatbot_title"]
-chatbot_description = config["chatbot_description"]
-chatbot_input_label = config["chatbot_input_label"]
-chatbot_input_placeholder = config["chatbot_input_placeholder"]
-chatbot_output_label = config["chatbot_output_label"]
-chatbot_output_placeholder = config["chatbot_output_placeholder"]
-chatbot_submit_button = config["chatbot_submit_button"]
-chatbot_reset_button = config["chatbot_reset_button"]
-
-# Check if the configuration parameters are set correctly
-if not all([chatbot_title, chatbot_description,
-            chatbot_input_label, chatbot_input_placeholder,
-            chatbot_output_label, chatbot_output_placeholder,
-            chatbot_submit_button, chatbot_reset_button]):
-    raise ValueError("One or more configuration parameters are missing or empty.")
-
-# Define the reset function
-def reset_output():
-    return []
-
-# Create a Gradio Blocks interface
-with gr.Blocks() as demo:
-    gr.Markdown(f"## {chatbot_title}\n{chatbot_description}")
-
-    # Chatbot history component
-    chatbot_output = gr.Chatbot(label="Chat History")
-    
-    # User input
-    user_input = gr.Textbox(
-        lines=2,
-        label=chatbot_input_label,
-        placeholder=chatbot_input_placeholder
-    )
-
-    # Buttons
-    with gr.Row():
-        # Reset button on the left (Gray)
-        with gr.Column(scale=1):
-            reset = gr.Button(chatbot_reset_button, variant="secondary")  
-        # Submit button on the right (Blue)
-        with gr.Column(scale=1):
-            submit = gr.Button(chatbot_submit_button, variant="primary")  
-
-    # Submit and Reset button actions
-    submit.click(fn=chat_interaction, inputs=[user_input, chatbot_output], outputs=chatbot_output)
-    user_input.submit(fn=chat_interaction, inputs=[user_input, chatbot_output], outputs=chatbot_output)
-    reset.click(fn=reset_output, inputs=None, outputs=chatbot_output)
+from utils.chatbot_logic import conversation  # Import the chatbot logic
+
+# Configure logging to both file and console
+log_file_path = "logs/chatbot_interface.log"  
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.FileHandler(log_file_path, mode='a', encoding='utf-8'),  # Save logs to a file
+        logging.StreamHandler()  # Print logs to the console
+    ]
+)
+
+class ChatbotInterface:
+    def __init__(self, config_path: str = 'config/gradio_config.json'):
+        """
+        Initialize the ChatbotInterface with configuration.
+        :param config_path: Path to the configuration JSON file.
+        """
+        self.config = self.load_config(config_path)
+        self.title = self.config["chatbot_title"]
+        self.description = self.config["chatbot_description"]
+        self.input_label = self.config["chatbot_input_label"]
+        self.input_placeholder = self.config["chatbot_input_placeholder"]
+        self.output_label = self.config["chatbot_output_label"]
+        self.reset_button = self.config["chatbot_reset_button"]
+        self.submit_button = self.config["chatbot_submit_button"]
+
+    @staticmethod
+    def load_config(config_path: str) -> dict:
+        """
+        Load the configuration for Gradio GUI interface from the JSON file.
+        :param config_path: Path to the configuration JSON file.
+        :return: Configuration dictionary.
+        """
+        if not os.path.exists(config_path):
+            logging.error(f"Configuration file not found: {config_path}")
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+        with open(config_path, 'r') as config_file:
+            config = json.load(config_file)
+
+        required_keys = [
+            "chatbot_title", "chatbot_description", "chatbot_input_label",
+            "chatbot_input_placeholder", "chatbot_output_label",
+            "chatbot_reset_button", "chatbot_submit_button"
+        ]
+        for key in required_keys:
+            if key not in config:
+                logging.error(f"Missing required configuration key: {key}")
+                raise ValueError(f"Missing required configuration key: {key}")
+
+        logging.info("Configuration loaded successfully.")
+        return config
+
+    def reset_output() -> list:
+        """
+        Reset the chatbot output.
+        :return: An empty list to reset the output.
+        """
+        return []
+
+    def create_interface(self) -> gr.Blocks:
+        """
+        Create the Gradio Blocks interface.
+        :return: A Gradio Blocks interface object.
+        """
+        with gr.Blocks() as demo:
+            gr.Markdown(f"## {self.title}\n{self.description}")
+
+            # Chatbot history component
+            chatbot_output = gr.Chatbot(label=self.output_label)
+
+            # User input
+            user_input = gr.Textbox(
+                lines=2,
+                label=self.input_label,
+                placeholder=self.input_placeholder
+            )
+
+            # Buttons
+            with gr.Row():
+                reset = gr.Button(self.reset_button, variant="secondary")
+                submit = gr.Button(self.submit_button, variant="primary")
+
+            # Button actions
+            submit.click(fn=conversation, inputs=[user_input, chatbot_output], outputs=chatbot_output)
+            user_input.submit(fn=conversation, inputs=[user_input, chatbot_output], outputs=chatbot_output)
+            reset.click(fn=self.reset_output, inputs=None, outputs=chatbot_output)
+
+        logging.info("Gradio interface created successfully.")
+        return demo
+
 
 if __name__ == "__main__":
-    demo.launch()
+    try:
+        # Instantiate the ChatbotInterface class and create the interface
+        chatbot_interface = ChatbotInterface()
+        demo = chatbot_interface.create_interface()
+
+        # Launch the Gradio interface
+        logging.info("Launching the Gradio interface...")
+        demo.launch()
+    except Exception as e:
+        logging.error(f"An error occurred: {e}")