Update app.py

app.py

@@ -1,208 +1,122 @@
-# Configure OpenAI KEY
-import openai as OpenAI
-from dotenv import load_dotenv
-from openai import OpenAI
-import os
+# Import necessary libraries
+from transformers import AutoTokenizer, AutoModelForCausalLM
 import gradio as gr
-
-# Utility package for English Prompts
-import utils
 import json
 from datetime import datetime
 
+# Load the GPT-2 model and tokenizer from Hugging Face
+tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
+model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
 
-# Load environment variables from .env file
-load_dotenv()
-
-# Set your OpenAI API key from the environment variable
-#api_key = os.getenv("HYPERBOLIC_API_KEY") # 'ollama'  
-#model = "meta-llama/Llama-3.2-90B-Vision-Instruct"  # "gpt-4o-mini"
-#base_url = "https://api.hyperbolic.xyz/v1/" # ollama 'http://localhost:11434/v1/'
-
-api_key = os.getenv("OPENAI_API_KEY") # 'ollama'  
-model = "gpt-4o-mini"  # "gpt-4o-mini"
-base_url = None
-
-
-client = OpenAI(
-    base_url=base_url,
-    api_key=api_key
-)
-
-
-def get_completion_from_messages(messages, 
-                                 model="gpt-4o-mini", 
-                                 temperature=0, 
-                                 max_tokens=500):
-    '''
-    Encapsulate a function to access LLM
-
-    Parameters: 
-    messages: This is a list of messages, each message is a dictionary containing role and content. The role can be 'system', 'user' or 'assistant', and the content is the message of the role.
-    model: The model to be called, default is gpt-4o-mini (ChatGPT) 
-    temperature: This determines the randomness of the model output, default is 0, meaning the output will be very deterministic. Increasing temperature will make the output more random.
-    max_tokens: This determines the maximum number of tokens in the model output.
-    '''
-    response = client.chat.completions.create(
-        messages=messages,
-        model=model, 
-        temperature=temperature, # This determines the randomness of the model's output
-        max_tokens=max_tokens, # This determines the maximum number of tokens in the model's output
-    )
-
-    return response.choices[0].message.content
-
-def process_user_message(user_input, all_messages, debug=True):
+# Utility function for generating responses using the GPT-2 model
+def generate_response(messages, max_tokens=500, temperature=0.7):
     """
-    Preprocess user messages
+    Generate a response from the model based on the input messages.
     
     Parameters:
-    user_input : User input
-    all_messages : Historical messages
-    debug : Whether to enable DEBUG mode, enabled by default
+    - messages: List of dictionaries containing the role and content of each message.
+    - max_tokens: Maximum number of tokens to generate.
+    - temperature: Controls randomness in the output.
+    
+    Returns:
+    - The generated response as a string.
     """
-    # Delimiter
-    delimiter = "```"
+    # Concatenate messages into a single prompt
+    prompt = "\n".join([f"{msg['role']}: {msg['content']}" for msg in messages])
     
-    # Step 1: Use OpenAI's Moderation API to check if the user input is compliant or an injected Prompt
-    response = client.moderations.create(input=user_input)
-    moderation_output = response.results[0]
-
-    # The input is non-compliant after Moderation API check
-    if moderation_output.flagged:
-        print("Step 1: Input rejected by Moderation")
-        return "Sorry, your request is non-compliant"
-
-    # If DEBUG mode is enabled, print real-time progress
-    if debug: 
-        print("Step 1: Input passed Moderation check")
-        print(f"\n**user_input**: {user_input}\n\n")
-    
-    # Step 2: Extract products and corresponding categories 
-    category_and_product_response = utils.find_category_and_product_only(
-        user_input, utils.get_products_and_category())
-    #print(category_and_product_response)
-    # Convert the extracted string to a list
-    category_and_product_list = utils.read_string_to_list(category_and_product_response)
-    #print(category_and_product_list)
-
-    if debug: print("Step 2: Extracted product list")
-
-    # Step 3: Find corresponding product information
-    product_information = utils.generate_output_string(category_and_product_list)
-    if debug: 
-        print("Step 3: Found information for extracted products")
-        print(f"\n**product_information**: {product_information}\n\n")
+    # Tokenize the input prompt
+    input_ids = tokenizer.encode(prompt, return_tensors='pt')
+    
+    # Generate response
+    output = model.generate(input_ids, max_length=len(input_ids[0]) + max_tokens, 
+                            temperature=temperature, pad_token_id=tokenizer.eos_token_id)
+    
+    # Decode the output to a string
+    response = tokenizer.decode(output[0], skip_special_tokens=True)
+    
+    # Return the generated response, excluding the input prompt for clarity
+    return response[len(prompt):].strip()
 
-    # Step 4: Generate answer based on information
-    system_message = f"""
-    You are a customer service assistant for a large electronic store. \
-    Respond in a friendly and helpful tone, with concise answers. \
-    Make sure to ask the user relevant follow-up questions.
+# Function to process user input and generate a response
+def process_user_message(user_input, all_messages, debug=True):
     """
-    # Insert message
-    messages = [
-        {'role': 'system', 'content': system_message},
-        {'role': 'user', 'content': f"{delimiter}{user_input}{delimiter}"},
-        {'role': 'assistant', 'content': f"Relevant product information:\n{product_information}"}
-    ]
-    # Get GPT3.5's answer
-    # Implement multi-turn dialogue by appending all_messages
-    final_response = get_completion_from_messages(all_messages + messages)
-    if debug:print("Step 4: Generated user answer")
-    # Add this round of information to historical messages
-    all_messages = all_messages + messages[1:]
-
-    # Step 5: Check if the output is compliant based on Moderation API
-    response = client.moderations.create(input=final_response)
-    moderation_output = response.results[0]
-
-    # Output is non-compliant
-    if moderation_output.flagged:
-        if debug: print("Step 5: Output rejected by Moderation")
-        return "Sorry, we cannot provide that information"
-
-    if debug: print("Step 5: Output passed Moderation check")
-
-    # Step 6: Model checks if the user's question is well answered
-    user_message = f"""
-    Customer message: {delimiter}{user_input}{delimiter}
-    Agent response: {delimiter}{final_response}{delimiter}
-
-    Does the response sufficiently answer the question? answer Yes or No
+    Process the user message and generate a response.
+    
+    Parameters:
+    - user_input: The input from the user.
+    - all_messages: A list of previous messages in the conversation.
+    - debug: Whether to enable debug logging.
+    
+    Returns:
+    - The response from the model and the updated message history.
     """
-    messages = [
-        {'role': 'system', 'content': system_message},
-        {'role': 'user', 'content': user_message}
-    ]
-    # Request model to evaluate the answer
-    evaluation_response = get_completion_from_messages(messages)
-    if debug: print("Step 6: Model evaluated the answer")
-
-    # Step 7: If evaluated as Y, output the answer; if evaluated as N, feedback that the answer will be manually corrected
-    if "Y" in evaluation_response:  # Use 'in' to avoid the model possibly generating Yes
-        if debug: print("Step 7: Model approved the answer.")
-        return final_response, all_messages, category_and_product_response
-    else:
-        if debug: print("Step 7: Model disapproved the answer.")
-        neg_str = "I apologize, but I cannot provide the information you need. I will transfer you to a human customer service representative for further assistance."
-        return neg_str, all_messages
-
-#Visual Interface
-#log messages
-messages_log = 'messages_log.json'
-
-def log_messages(new_element, filepath):
- # Update the messages_log with the new assistant response
-    filepath = 'messages_log.json'
+    # Add the user's message to the conversation history
+    all_messages.append({'role': 'user', 'content': user_input})
+    
+    # Define a system message for context
+    system_message = {
+        'role': 'system', 
+        'content': "You are a helpful assistant. Answer the user's question as accurately as possible."
+    }
+    
+    # Include the system message and conversation history
+    messages = [system_message] + all_messages
+    
+    # Generate a response using the model
+    response = generate_response(messages, max_tokens=500, temperature=0.7)
+    
+    # Add the model's response to the conversation history
+    all_messages.append({'role': 'assistant', 'content': response})
+    
+    # If debug is enabled, print the conversation history
+    if debug:
+        print("Conversation History:")
+        for msg in all_messages:
+            print(f"{msg['role']}: {msg['content']}")
+    
+    return response, all_messages
 
+# Function to log the messages to a JSON file
+def log_messages(new_element, filepath='messages_log.json'):
     try:
         with open(filepath, "r") as file:
-            # Check if the file is empty
             if file.read().strip() == "":
-                data = []  # Initialize with an empty list or dictionary as needed
+                data = []
             else:
-                file.seek(0)  # Move the cursor back to the start of the file
+                file.seek(0)
                 data = json.load(file)
-    except FileNotFoundError:
-        # If the file doesn't exist, start with an empty list or dictionary
-        data = []
-    except json.JSONDecodeError:
-        # If there is a JSON decoding error, handle it by initializing empty data
-        print("Error: The JSON file is not properly formatted.")
+    except (FileNotFoundError, json.JSONDecodeError):
         data = []
     
-    # Assuming the data is a list of items
     data.append(new_element)
-
+    
     with open(filepath, "w") as file:
         json.dump(data, file, indent=4)
 
-# Initialize the context as an empty list to keep track of the conversation history
+# Initialize an empty list to keep track of the conversation history
 context = []
 
 # Function to collect and process user messages
 def collect_messages_en(input_text, debug=True):
-    global context  # Use the global messages_log to track all messages
+    global context
 
-    if debug: print(f"User Input = {input_text}")
+    if debug: 
+        print(f"User Input: {input_text}")
     if input_text == "":
         return
-    #context = get_messages()
-    # Process the user input and get a response
-    response, context, product_category = process_user_message(input_text, context, debug=debug)
-    context.append({'role':'assistant', 'content':f"{response}"})
-
+    
+    # Process the user input and generate a response
+    response, context = process_user_message(input_text, context, debug=debug)
+    
     # Get the current timestamp
-    current_timestamp = datetime.now()
-    formatted_timestamp = current_timestamp.strftime("%Y-%m-%d %H:%M:%S")
-
-    #log the messages
-    log_messages({'time_stamp': formatted_timestamp, 'user_input': input_text, 'AI_response': response, 'metadata': product_category}, messages_log)
-    # Return the response to be displayed in the Gradio interface
+    current_timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    # Log the messages
+    log_messages({'time_stamp': current_timestamp, 'user_input': input_text, 'AI_response': response})
+    
     return response
 
-# Create a Gradio interface for interacting with the assistant
+# Create a Gradio interface for the assistant
 demo = gr.Interface(
     fn=collect_messages_en, 
     inputs=gr.Textbox(lines=3, label="Inquiries", placeholder="Ask us anything..."),
@@ -212,6 +126,3 @@ demo = gr.Interface(
 )
 
 demo.launch()
-
-# user_input = "tell me about the smartx pro phone and the fotosnap camera, the dslr one. Also what tell me about your tvs"
-