Version 2

chat_logic/chat_stream.py

@@ -5,58 +5,30 @@ from rag.vectorization_functions import split_documents, create_embedding_vector
 from rag.ifixit_document_retrieval import load_ifixit_guides
 #model
 from helper_functions.llm_base_client import llm_base_client_init
+from chat_logic.prompts import load_prompts
 
 
-def chatbot_interface(history, user_query):
+def chatbot_answer(user_query, memory=None,  context="", prompt="default", response_type=None, modelname="llama3-8b-8192", temp=0.3):
     """ 
 
-    LLM Model is defined here.
-    Chat history use and chat with user coded here.
-    
-    """
-    
-    if not user_query.strip():
-        return history + [(user_query, "Hey, I'd love to help you! What can I do for you?")]
-    
-    messages = [{"role": "system",
-              "content":  """You are a helpful assistant 
-              that helps users with the repair of their devices. Ask them if they need help with a repair.
-              If they do, ask them to provide the device name and model."""}]
-    
-    if history:
-        for user_msg, bot_msg in history:
-            messages.append({"role": "user", "content": user_msg})
-            messages.append({"role": "assistant", "content": bot_msg})
-    messages.append({"role": "user", "content": user_query})
-    print(messages)
-
-    client = llm_base_client_init()
+    Gererate a response from the model based on the user's query and chat history.
+    Can be used for both the first query and follow-up questions by using different prompts.
 
-    chat_completion = client.chat.completions.create(
-        messages=messages,
-        model="llama3-8b-8192",
-        temperature=0.3
-    )
-
-    return history + [(user_query, chat_completion.choices[0].message.content)]  
+    Args:
+        user_query (str): The user's query.
+        memory (list): The chat history.
+        context (str): The context to use in the prompt.
+        prompt (str): The prompt to load.
+        response_type (str): The style of language the answer should use.
+        modelname (str): The name of the model to use.
+        temp (float): The temperature for the model.
 
-#%% 
-# processing functions
-from rag.vectorization_functions import split_documents, create_embedding_vector_db, query_vector_db
-# lead ifixit infos
-from rag.ifixit_document_retrieval import load_ifixit_guides
-#model
-from helper_functions.llm_base_client import llm_base_client_init
-from chat_logic.prompts import load_prompts
-
-def chatbot_answer(user_query, memory=None,  context="", prompt="default", modelname="llama3-8b-8192", temp=0.3):
-    """ 
-
-    Chat history use and chat with user coded here.
+    Returns:
+        str: The model's response.
     
     """
     client = llm_base_client_init()
-    answer_prompt = load_prompts(prompt, context)
+    answer_prompt = load_prompts(prompt, context, response_type)
     messages = [{"role": "system",
               "content": answer_prompt}]
     
@@ -75,11 +47,19 @@ def chatbot_answer(user_query, memory=None,  context="", prompt="default", model
     return chat_completion
 
 
-def chatbot_interface(history, user_query):
+def chatbot_interface(history, user_query, response_type=None):
     """ 
 
-    LLM Model is defined here.
-    Chat history use and chat with user coded here.
+    UI uses this function to handle general chat functionality. 
+    Order of operations is also defined here.
+
+    Args:
+        history (list): The chat history.
+        user_query (str): The user's query.
+        response_type (str): The style of language the answer should use.
+    
+    Returns:
+        list: The model's response added to the chat history.
     
     """
 
@@ -90,31 +70,17 @@ def chatbot_interface(history, user_query):
         global vector_db
         vector_db = create_embedding_vector_db(chunks)
         context = query_vector_db(user_query, vector_db)
-        message_content = chatbot_answer(user_query, history, context, prompt="repair_guide")
+        message_content = chatbot_answer(user_query, history, context, prompt="repair_guide", response_type=response_type)
         answer = history + [(user_query, message_content.choices[0].message.content)]
         return answer
     
     # answer questions to the guide 
     else: 
         context = query_vector_db(user_query, vector_db)
-        message_content = chatbot_answer(user_query, history, context, prompt="repair_helper")
+        message_content = chatbot_answer(user_query, history, context, prompt="repair_helper", response_type=response_type)
         answer = history + [(user_query, message_content.choices[0].message.content)]
         return answer
-
-                    
-
-# Not implemented yet:
-def answer_style(history, user_query, response_type):
-    response = f"Suggested repair steps for: {user_query}\n\n"
-    if response_type == "Simple Language":
-        response += "Please provide a clear and easy-to-understand explanation."
-    elif response_type == "Technical":
-        response += "Provide a detailed technical breakdown of the repair process."
-    
-    history.append((user_query, response))  # Append to chat history
-    return history
-
-
+                
 # Feedback function for thumbs up (chat ends with success message)
 def feedback_positive(history):
     history.append((None, "🎉 Great! We're happy to hear that your repair was successful! If you need help in the future, feel free to ask."))

chat_logic/prompts.py

@@ -1,20 +1,47 @@
-def load_prompts(prompt, context=""):
+def load_prompts(prompt, context="", response_type=None):
     """
     Load the prompts from a file or define them in the code.
 
+    Args:
+        prompt (str): The prompt to load.
+        context (str): The context to use in the prompt.
+        response_type (str): The style of language the answer should use.
+
+    Returns: 
+        str: The loaded prompt.
+
     """
-    # You can load these prompts
+ 
+    # choose response_type
+    if response_type == "Simple Language":
+        response_type = "Use plain language and explain so that a 5th grader would understand."
+
+    if response_type == "Technical":
+        response_type = "Use technical jargon and provide detailed explanations."
+
+    if response_type == "Homer Simpson Language":
+        response_type = "Use simple language and explain it like Homer Simpson would."
+    
+    if response_type == "Sarcasm":
+        response_type = "Use sarcastic language and tone."
+    
+    if response_type is None:
+        response_type = ""
 
+    # choose prompt and append response_type
     if prompt == "default":
-        return """You are a helpful assistant that helps users with the repair of their devices.
+        prompt = ("""You are a helpful assistant that helps users with the repair of their devices.
                   Ask them if they need help with a repair.
-                  If they do, ask them to provide the device name and model."""
+                  If they do, ask them to provide the device name and model. """ + response_type)
     
     if prompt == "repair_guide":
-        return (f"List repair steps for the Problem. Use the following context:\n{context}")
+        prompt = (f"List repair steps for the Problem. Use the following context:\n{context}. " + response_type)
     
     if prompt == "repair_helper":
-        return (f"Answer the users question about the guide. Use the following context:\n{context}")
+        prompt = (f"Answer the users question about the guide. Use the following context:\n{context}. " + response_type)
+
+    return prompt
+
    
     
     

rag/ifixit_document_retrieval.py

@@ -8,6 +8,9 @@ def write_searchphrase(search_info: str, debug: bool = False):
 
     Args:
         search_info (str): The information to be turned into a searchphrase.
+
+    Returns:
+        str: The rewritten searchphrase.
     """
     client = llm_base_client_init()
     

rag/vectorization_functions.py

@@ -8,7 +8,15 @@ from helper_functions.llm_base_client import llm_base_client_init
 
 def split_documents(documents, chunk_size=800, chunk_overlap=80): # check chunk size and overlap for our purpose
     """
-    this function splits documents into chunks of given size and overlap
+    This function splits documents into chunks of given size and overlap.
+
+    Args:
+        documents (list): List of documents to be split.
+        chunk_size (int): Size of each chunk.
+        chunk_overlap (int): Overlap between chunks.
+    
+    Returns:    
+        list: List of text chunks.
     """
     text_splitter = RecursiveCharacterTextSplitter(
         chunk_size=chunk_size,
@@ -17,12 +25,17 @@ def split_documents(documents, chunk_size=800, chunk_overlap=80): # check chunk
     chunks = text_splitter.split_documents(documents=documents)
     return chunks
 
-def create_embedding_vector_db(chunks #, db_name, target_directory=f"../vector_databases"
-                               ):
+def create_embedding_vector_db(chunks):
     """
-    this function uses the open-source embedding model HuggingFaceEmbeddings 
+    Uses the open-source embedding model HuggingFaceEmbeddings 
     to create embeddings and store those in a vector database called FAISS, 
     which allows for efficient similarity search
+
+    Args:
+        chunks (list): List of text chunks to be embedded.
+    
+    Returns:
+        vector_db: The vector database containing the embedded chunks.
     """
     # instantiate embedding model
     embedding = HuggingFaceEmbeddings(
@@ -35,23 +48,22 @@ def create_embedding_vector_db(chunks #, db_name, target_directory=f"../vector_d
     )
     return vector_db # optimize
 
-#Function to query the vector database and interact with Groq
+# Function to query the vector database and interact with Groq
 def query_vector_db(query, vector_db):
+    """
+    This function queries the vector database with the user query and retrieves relevant documents
+
+    Args:
+        query (str): The user query.
+        vector_db: The vector database to query.
+    
+    Returns:
+        str: The context retrieved from the vector database.
+
+    """
     # Retrieve relevant documents
     docs = vector_db.similarity_search(query, k=3) # neigbors k are the chunks # similarity_search: FAISS function
     context = "\n".join([doc.page_content for doc in docs])
 
     return context
 
-    # client = llm_base_client_init() 
-    # # Interact with Groq API
-    # chat_completion = client.chat.completions.create(
-    #     messages=[
-    #         {"role": "system",
-    #          "content": f"List repair steps for the Problem. Use the following context:\n{context}"},
-    #         {"role": "user", "content": query},
-    #     ],
-    #     model="llama3-8b-8192",
-    #     temperature=0.3 # optional: check best value!
-    # )
-    # return chat_completion.choices[0].message.content

ui/custom_css.py

@@ -1,5 +1,12 @@
+# Load a custom CSS for Gradio interface
 
 def custom_css():
+    """
+    Custom CSS for Gradio interface to style buttons, chat container, and background.
+
+    Returns:
+        str: Custom CSS styles.
+    """
     custom_css = """
     <style>
         .submit-button {
@@ -25,6 +32,9 @@ def custom_css():
             gap: 10px;
             margin-top: 5px;
         }
+        .gradio-container {
+            background-color: #74BA9C !important;
+        }
     </style>
     """
     return custom_css

ui/interface_design.py

@@ -1,15 +1,15 @@
 
 #%%
 
-
-#NEW
-
 import gradio as gr
-import os
 from chat_logic.chat_stream import chatbot_interface, feedback_positive, feedback_negative
 from ui.custom_css import custom_css
 
 def interface_init():
+    """
+    Initialize the Gradio interface for the Repair Assistant chatbot.
+
+    """
    
     logo_path = "./images/logo.png"
 
@@ -20,43 +20,29 @@ def interface_init():
         gr.Markdown("### Repair Assistant - Fix smarter with AI")
         gr.Markdown("State your repair topic, select your response style and start chatting.")
 
-        # Input field
-        #question = gr.Textbox(label="Your Question", placeholder="What would you like to repair? Please name make, model and problem.")
-
-        # Submit button
-        #submit_button = gr.Button("Submit", elem_classes="submit-button")
-
         # Chat interface & state
         chat_history = gr.State([])
         chatbot = gr.Chatbot()
         user_input = gr.Textbox(placeholder="What would you like to repair? Please name make, model and problem.")
+        response_type = gr.Radio(["Simple Language", "Technical", "Homer Simpson Language", "Sarcasm"], label="Answer Style")
         submit_btn = gr.Button("Submit", elem_classes="submit-button")
 
-        submit_btn.click(chatbot_interface, [chatbot, user_input], chatbot)
-        user_input.submit(chatbot_interface, [chatbot, user_input], chatbot)
-
-        # Response style selection
-        response_type = gr.Radio(["Simple Language", "Technical"], label="Answer Style")
-
-        # Connect the start button to chat initialization
-        #submit_button.click(fn=start_chat, inputs=[question,response_type], outputs=[chat_history, chatbot, chatbot])
+        submit_btn.click(fn=chatbot_interface, inputs=[chatbot, user_input, response_type], outputs=chatbot)
+        user_input.submit(chatbot_interface, [chatbot, user_input, response_type], chatbot)
 
         # "Did the repair work?" label
         gr.Markdown("**Did the repair work?**")
 
-        # Feedback buttons
+        # Feedback buttons (not functional yet)
         with gr.Row(elem_classes="feedback-buttons"):
             thumbs_up = gr.Button("👍 Yes")
             thumbs_down = gr.Button("👎 No")
 
-        # Connect submit button to chatbot function
-        #submit_button.click(fn=repair_assistant, inputs=[chat_history, question, response_type], outputs=chatbot)
-
         # Connect thumbs up to success message (stops chat)
-        #thumbs_up.click(fn=feedback_positive, inputs=[chat_history], outputs=chatbot)
+        thumbs_up.click(fn=feedback_positive, inputs=[chat_history], outputs=chatbot)
 
         # Connect thumbs down to continue troubleshooting
-       # thumbs_down.click(fn=feedback_negative, inputs=[chat_history], outputs=chatbot)
+        thumbs_down.click(fn=feedback_negative, inputs=[chat_history], outputs=chatbot)
+        
     app.queue().launch()
 
-# %%