Initial code

app.py

@@ -1,64 +1,80 @@
+import os
+import json
 import gradio as gr
-from huggingface_hub import InferenceClient
-
+from utils.response_manager import ResponseManager  # Import the ResponseManager class 
 """
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+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.
 """
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
+# 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')
 
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
+# 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.")
 
-    messages.append({"role": "user", "content": message})
+# Initialize the ResponseManager with the vector store ID
+response_manager = ResponseManager(vector_store_id)
 
-    response = ""
+# 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
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
+# 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
+title = config["chatbot_title"]
+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"]
 
-        response += token
-        yield response
+# Check if the configuration parameters are set correctly
+if not all([header_message, title, 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 chatbot function to handle user queries and generate responses
+def chatbot(query: str) -> str:
+    """
+    Function to handle the chatbot interaction.
+    :param query: The user query to respond to.
+    :return: The response text from the chatbot.
+    """
+    try:
+        if query.strip():
+            response = response_manager.create_response(query, model, temperature, max_output_tokens, max_num_results)
+            if not response:
+                return "Sorry, I couldn't generate a response at this time. Please try again later."
+            # Return the response from the AI model
+            return response
+        else:
+            return "Please enter a valid query."
+    except Exception as e:
+        return str(e)
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
+# Create a Gradio GUI interface
+inputs = gr.Textbox(lines=7, label=chatbot_input_label, placeholder=chatbot_input_placeholder)
+outputs = gr.Textbox(label=chatbot_output_label, placeholder=chatbot_output_placeholder)
+iface = gr.Interface(fn=chatbot, 
+                     inputs=inputs, 
+                     outputs=outputs, 
+                     title=title,
+                     description=description,
+                     theme="default",
+                     live=True)
 
 if __name__ == "__main__":
-    demo.launch()
+    iface.launch()

config/gradio_config.json

@@ -0,0 +1,14 @@
+{
+    "chatbot_header_message": "Ask anything about the Harvey Mudd College CIS services",
+    "chatbot_title": "AI assistant for the Computing and Information Services (CIS) Helpdesk at Harvey Mudd College (HMC)",
+    "chatbot_description": "This is an AI chatbot for HMC CIS services", 
+    "chatbot_input_label": "Type your question here",
+    "chatbot_input_placeholder": "What would you like to know?",
+    "chatbot_output_label": "Response",
+    "chatbot_output_placeholder": "The AI assistant will respond here",
+    "chatbot_submit_button": "Ask",
+    "chatbot_reset_button": "Reset"
+}
+// This JSON file contains configuration settings for a Gradio chatbot interface.
+// It includes settings for the header message, title, description, input and output labels,
+// placeholders, and button labels. 

requirements.txt

@@ -1 +1,2 @@
-huggingface_hub==0.25.2
+huggingface_hub==0.25.2
+openai==1.66.3

utils/response_manager.py

@@ -0,0 +1,80 @@
+import os
+import openai
+"""
+A module to manage responses from the OpenAI Response API for an IT Helpdesk assistant 
+at Harvey Mudd College. This module initializes the OpenAI client and provides a method 
+to create responses using RAG (Retrieval-Augmented Generation) to user queries. It uses 
+a vector store for retrieval of knowledge base documents and generates responses using 
+the specified OpenAI model. The module also loads a developer message from a text file 
+to prompt engineer responses from the AI model.
+"""
+
+# Load the OpenAI API key from the environment variable
+# If the API key is not set, raise an error.
+if "OPENAI_API_KEY" not in os.environ:
+    raise ValueError("OPENAI_API_KEY environment variable is not set.")
+api_key=os.getenv("OPENAI_API_KEY")
+
+class ResponseManager:
+    """
+    A class to manage responses from the OpenAI API for an IT Helpdesk assistant.
+    This class initializes the OpenAI client and provides a method to create responses
+    to user queries using the specified OpenAI model.
+    """
+    def __init__(self, vector_store_id):
+        """
+        Initialize the ResponseManager with a vector store ID.
+        :param vector_store_id: The ID of the vector store to use for file search.
+        """
+        # Initialize the OpenAI client
+        # Note: The OpenAI client is initialized with the API key set in the environment variable
+        # This is a placeholder for the actual OpenAI client initialization
+        # In a real-world scenario, you would use the appropriate OpenAI client library
+        # For example, if using the OpenAI Python library, you would do:    
+        self.client = openai.OpenAI(api_key=api_key)
+        self.vector_store_id = vector_store_id
+        self.previous_response_id = None
+        
+        # Load the meta prompt from the text file
+        # This message is used to provide context for the AI model
+        meta_prompt_file = 'config/meta_prompt.txt'
+        if not os.path.exists(developer_message_file):
+            raise FileNotFoundError(f"Meta prompt file '{meta_prompt_file}' not found.")
+        with open(meta_prompt_file, 'r') as file:
+            self.meta_prompt_file = file.read().strip()
+
+    def create_response(self, query, model: str= "gpt-4o-mini",
+                        temperature=0, max_output_tokens=800,
+                        max_num_results=7):
+        """
+        Create a response to a user query using the OpenAI API.
+        :param query: The user query to respond to.
+        :param model: The OpenAI model to use (default is "gpt-4o-mini").
+        :param temperature: The temperature for the response (default is 0).
+        :param max_output_tokens: The maximum number of output tokens (default is 800).
+        :param max_num_results: The maximum number of search results to return (default is 7).
+        :param verbose: Whether to print the response (default is False).
+        :return: The response text from the OpenAI API.
+        """
+        if self.previous_response_id is None:
+            input=[{"role": "developer", "content": self.developer_message}, 
+                   {"role": "user", "content": query}]
+        else:
+            input=[{"role": "user", "content": query}]
+
+        response = self.client.responses.create(
+            model=model,
+            previous_response_id=self.previous_response_id,
+            input=input,
+            tools=[{
+                "type": "file_search",
+                "vector_store_ids": [self.vector_store_id], # ["<vector_store_id>"]
+                "max_num_results": max_num_results}
+            ],
+            temperature=temperature,
+            max_output_tokens = max_output_tokens,
+            # include=["output[*].file_search_call.search_results"]
+        )
+        self.previous_response_id = response.id
+
+        return response.output_text