updated version

chat_logic/chat_stream.py

@@ -4,14 +4,16 @@ from rag.vectorization_functions import split_documents, create_embedding_vector
 # 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 helper_functions.llm_client_initialization import llm_base_client_init
 from chat_logic.prompts import load_prompts
-
+from chat_logic.diagnosis import information_extractor
+import time
+import gradio as gr
 
 def chatbot_answer(user_query, memory=None,  context="", prompt="default", response_type=None, modelname="llama3-8b-8192", temp=0.3):
     """ 
 
-    Gererate a response from the model based on the user's query and chat history.
+    Generate 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.
 
     Args:
@@ -34,8 +36,10 @@ def chatbot_answer(user_query, memory=None,  context="", prompt="default", respo
     
     if memory:
         for user_msg, bot_msg in memory:
-            messages.append({"role": "user", "content": user_msg})
-            messages.append({"role": "assistant", "content": bot_msg})
+            if user_msg and user_msg != None:
+                messages.append({"role": "user", "content": user_msg})
+            if bot_msg:
+                messages.append({"role": "assistant", "content": bot_msg})
     messages.append({"role": "user", "content": user_query})
 
     # calling the LLM with the entire chat history in order to get an answer
@@ -46,8 +50,40 @@ def chatbot_answer(user_query, memory=None,  context="", prompt="default", respo
     )
     return chat_completion
 
+def chatbot_answer_init(user_query, vector_db, history, response_type, prompt, k=5, modelname="llama3-8b-8192", temp=0.3, history_length=5):
+    """
+    Generate the answer for the answer for the query.
+
+    Args:
+        user_query (str): The user's query.
+        vector_db: The vector database to query.
+        history (list): The chat history.
+        response_type (str): The style of language the answer should use.
+        prompt (str): The prompt to load.
+    returns:
+        answer (list): The model's response added to the chat history.
+    """
+    if vector_db:
+        context = query_vector_db(user_query, vector_db, k)
+    else:
+        context = ""
+
+    message_content = chatbot_answer(user_query, history[-(history_length):], context, prompt, response_type, modelname, temp)
+    answer = history + [[user_query, message_content.choices[0].message.content]]
+    return answer
 
-def chatbot_interface(history, user_query, response_type=None):
+def chatbot_rag_init(user_query):
+    """
+    Create the vector database for the first query.
+    This function loads the guides, splits them into chunks, and creates the embedding vector database.
+    """
+    
+    data = load_ifixit_guides(user_query, debug=True)
+    chunks = split_documents(data)
+    vector_database = create_embedding_vector_db(chunks)
+    return vector_database
+
+def chatbot_interface(history, user_query, response_type, conversation_state):
     """ 
 
     UI uses this function to handle general chat functionality. 
@@ -62,31 +98,101 @@ def chatbot_interface(history, user_query, response_type=None):
         list: The model's response added to the chat history.
     
     """
+    #Diagnose issue
+    if conversation_state == 'interactive_diagnosis':
+        answer = chatbot_answer_init(user_query, None, history, response_type, prompt="diagnose_issue")
+        extracted_info = information_extractor(answer)
+    
+        if any(value == '' or (value is not None and 'none' in value.lower()) or 
+            (value is not None and 'not specified' in value.lower()) or 
+            (value is not None and 'unknown' in value.lower())
+            for value in extracted_info.values()
+            ):
+            conversation_state = "interactive_diagnosis"
+        else:
+            global vector_db
+            vector_db = [] # reset vector database to avoid memory issues
+            vector_db = chatbot_rag_init(answer[-1][1])
 
+            repair_question = f"List repair steps for {extracted_info['issue']} of {extracted_info['brand']} {extracted_info['model']}."
+
+            answer = chatbot_answer_init(repair_question,
+                                         vector_db,
+                                         history,
+                                         response_type,
+                                         prompt="repair_guide",
+                                        k=10,
+                                        modelname="llama-3.1-8b-instant",
+                                        temp=0.3)
+            conversation_state = "repair_mode"
+
+    elif conversation_state == 'repair_mode':
+        answer = chatbot_answer_init(user_query,
+                                    vector_db,
+                                    history,
+                                    response_type,
+                                    prompt="repair_helper",
+                                    k=5)
     # load guides, create embeddings and return answer for first query
-    if len(history) == 0:
-        data = load_ifixit_guides(user_query, debug=True)
-        chunks = split_documents(data)
-        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", 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", response_type=response_type)
-        answer = history + [(user_query, message_content.choices[0].message.content)]
-        return answer
-                
-# Feedback function for thumbs up (chat ends with success message)
+    print("Answer before returning to Handle User INput:", answer)
+    return answer, conversation_state
+
+def handle_user_input(user_input_text, history, conversation_state, response_type):
+    print(conversation_state)
+    print(type(conversation_state))
+    print("History before calling Chatbot Interface:", history)
+
+    if conversation_state == "awaiting_support_confirmation":
+        yield from support_ticket_needed(user_input_text, history, conversation_state)
+    else:
+        answer, conversation_state = chatbot_interface(history, user_input_text, response_type, conversation_state)
+        print("Answer before returning to Interface Design:", answer)
+        print("Conversation state before returning to Interface Design:", conversation_state)
+        yield answer, "", conversation_state
+
+# Feedback function for thumbs up (chat ends with success message & restarts)
 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."))
-    return history
+    history.append([None, "<br><br><br>🎉 Great! We're happy to hear that your repair was successful! If you need help in the future, feel free to ask. I will automatically restart the chat."])
+    print("Chat history:", history)
+    conversation_state = "repair_helper"
+    yield history, gr.update(value=""), conversation_state # shows message
+    time.sleep(5) # short break for message to remain
+    history.clear()
+    conversation_state = "interactive_diagnosis"
+    print("History after clearing:", history) 
+    yield [], gr.update(value=""), conversation_state # reset chat
 
-# Feedback function for thumbs down (chat continues)
+# Feedback function for thumbs down
 def feedback_negative(history):
-    history.append((None, "I'm sorry to hear that. Could you describe the issue further? Maybe we can find another solution."))
-    return history
+    history.append((None, "<br><br><br>I'm sorry to hear that. Do you want me to create a support ticket for you so that you can seek professional help?"))
+    print("Chat history:", history)
+    conversation_state = "awaiting_support_confirmation"
+    yield history, conversation_state
+
+# Support ticket creation
+def support_ticket_needed(message, history, conversation_state):
+    user_message = message.strip().lower()
+    history.append((message, None))
+    if conversation_state == "awaiting_support_confirmation":
+        if "yes" in user_message:
+            ticket_text = chatbot_answer_init("Please summarize this history into a support ticket.",
+                                            vector_db,
+                                            history,
+                                            response_type="Technical",
+                                            prompt="support_ticket",
+                                            history_length=len(history)
+                                            )
+            history.append((None, f"🛠️ Your support ticket has been created:\n\n{ticket_text[-1][1]}"))
+            conversation_state = "repair_helper"
+            yield history, "", conversation_state
+        elif "no" in user_message:
+            history.append((None, "👍 Ok, I would be happy to help with the next repair problem."))
+            yield history, "", conversation_state
+            time.sleep(5)
+            history.clear()
+            conversation_state = "interactive_diagnosis"
+            yield history, "", conversation_state
+        else:
+            history.append((None, "❓ Please answer with yes or no."))
+            yield history, "", conversation_state
+

chat_logic/diagnosis.py

@@ -0,0 +1,75 @@
+#%% 
+# processing functions
+# lead ifixit infos
+
+from langchain.chat_models import init_chat_model
+from langchain.output_parsers import StructuredOutputParser, ResponseSchema
+from langchain.prompts import ChatPromptTemplate
+# import langchain groq package
+from helper_functions.llm_client_initialization import llm_langchain_client_init
+import re
+
+
+def information_extractor(conversation):
+    """
+    Extracts the device, brand, model and issue from the conversation using a language model.
+    Input: entire diagnosis conversation between bot and user
+    Output: dictionary with device, brand, model and issue
+    """
+    # Initializing the Grog Client
+    llm = llm_langchain_client_init()
+    # Defining the information we want to extract from the response
+    schemas = [
+        ResponseSchema(name="device", description="Device or appliance mentioned, if any"), # one line per information that we are trying to extract
+        ResponseSchema(name="brand", description="Brand of device or appliance mentioned, if any"), # one line per information that we are trying to extract
+        ResponseSchema(name="model", description="Model of device or appliance mentioned, if any"), # one line per information that we are trying to extract
+        ResponseSchema(name="issue", description="Main issue or concern with device or appliance, if any. Leave empty if none.")
+        ]
+    
+    # Initialization of the parser
+    parser = StructuredOutputParser.from_response_schemas(schemas)
+
+    print(parser)
+
+    # Defining the chat prompt template
+    prompt = ChatPromptTemplate.from_messages([
+    ("system", "Extract the following info from the message of the user."),
+    ("user", "{text}\n\n{format_instructions}")
+    ])
+    
+    # Defining parsing instructions for the output
+    #Theoretically, the parser is to generate the parsing instructions automatically,
+    # but it cannot tell the client to remove the comments in the output, which leads to errors when parsing the json downstream 
+    parsing_instructions ='''
+        The output should be a markdown code snippet formatted in the following schema,
+        including the leading and trailing "```json" and "```", without any additional text or comments:
+
+        ```json
+        {
+            "device": string  // Device or appliance mentioned, if any
+            "brand": string  // Brand of device or appliance mentioned, if any
+            "model": string  // Model of device or appliance mentioned, if any
+            "issue": string  // Main issue or concern with device or appliance, if any. Leave empty if none.
+        }
+        ```
+        '''
+    
+    # Formattig the prompt with last message in the conversation and instructions to parse the information from that message
+    formatted_prompt = prompt.format_prompt(
+    text=conversation[-1][1],  # The last message in the conversation
+    format_instructions=parsing_instructions
+    )
+
+    print('Text parsed by LLM: ', conversation[-1][1])
+    
+    # Calling the LLM with the formatted prompt and parsing the output
+    output = llm(formatted_prompt.to_messages())
+    print("Output Content: " + output.content)
+
+    cleaned_content = re.sub(r'//.*$', '', output.content, flags=re.MULTILINE)
+
+    print("Cleanded Content: " + cleaned_content)
+    
+    parsed_content = parser.parse(cleaned_content)
+    print("Dictionary: ", parsed_content)
+    return parsed_content

chat_logic/prompts.py

@@ -1,4 +1,4 @@
-def load_prompts(prompt, context="", response_type=None):
+def load_prompts(prompt="default", context="", response_type=None):
     """
     Load the prompts from a file or define them in the code.
 
@@ -16,16 +16,16 @@ def load_prompts(prompt, context="", response_type=None):
     if response_type == "Simple Language":
         response_type = "Use plain language and explain so that a 5th grader would understand."
 
-    if response_type == "Technical":
+    elif response_type == "Technical":
         response_type = "Use technical jargon and provide detailed explanations."
 
-    if response_type == "Homer Simpson Language":
+    elif response_type == "Homer Simpson Language":
         response_type = "Use simple language and explain it like Homer Simpson would."
     
-    if response_type == "Sarcasm":
+    elif response_type == "Sarcasm":
         response_type = "Use sarcastic language and tone."
     
-    if response_type is None:
+    elif response_type is None:
         response_type = ""
 
     # choose prompt and append response_type
@@ -33,15 +33,36 @@ def load_prompts(prompt, context="", response_type=None):
         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. """ + response_type)
+        
+    elif prompt == "diagnose_issue":
+        prompt = ("""
+                You are a helpful assistant.
+                Your job is to determine if an appliance or device, the brand of the appliance or device,
+                the model of the appliance or device and the user's issue with the applicance or device
+                were mentioned in the user's message.
+                If yes, extract the appliance or device, its model and its issue and confirm it back to the user and stop asking for information.
+                If not, continue to ask the user to provide the missing information until they provide it.
+                Do not provide troubleshooting steps or solutions.""" + response_type)
     
-    if prompt == "repair_guide":
+    elif prompt == "repair_guide":
         prompt = (f"List repair steps for the Problem. Use the following context:\n{context}. " + response_type)
     
-    if prompt == "repair_helper":
+    elif prompt == "repair_helper":
         prompt = (f"Answer the users question about the guide. Use the following context:\n{context}. " + response_type)
+    
+    # create support ticket
+    elif prompt == "support_ticket":
+        prompt = ("""
+                    You are a technical support assistant. Based on the user's input, generate a structured support ticket with the following fields:
+                    1. Device Type
+                    2. Brand and Model
+                    3. Serial Number (if available)
+                    4. Problem Description
+                    5. Troubleshooting Steps Already Taken
+                    6. Additional Notes (if available)
 
-    return prompt
+                    Ensure the ticket is clear and concise, suitable for submission to a professional repair service.
 
-   
-    
-    
+                    """ + response_type)
+
+    return prompt

helper_functions/llm_base_client.py

@@ -1,12 +0,0 @@
-#%%
-import os
-from dotenv import load_dotenv
-from groq import Groq
-
-def llm_base_client_init():
-    load_dotenv()
-    groq_key = os.getenv('GROQ_API_KEY')
-    client = Groq(api_key=groq_key)
-
-    return client
-

helper_functions/llm_client_initialization.py

@@ -0,0 +1,31 @@
+#%%
+import os
+from dotenv import load_dotenv
+from groq import Groq
+from langchain_groq import ChatGroq
+
+def llm_base_client_init():
+    load_dotenv()
+    groq_key = os.getenv('GROQ_API_KEY')
+    client = Groq(api_key=groq_key)
+
+    return client
+
+def llm_langchain_client_init(modelname="llama-3.1-8b-instant", temp=0.2):
+    '''
+    Initializes the LLM client using the langchain_groq package.
+    Parameters:
+    modelname (str): The name of the model to use. Other models: "meta-llama/llama-4-scout-17b-16e-instruct"
+    '''
+    load_dotenv()
+    groq_key = os.getenv('GROQ_API_KEY')
+
+    client = ChatGroq(
+        model=modelname,
+        temperature=temp,
+        max_tokens=None,
+        timeout=None,
+        max_retries=2,
+        api_key=groq_key
+        )
+    return client

helper_functions/load_embed_model.py

@@ -0,0 +1 @@
+embedding_model = None

main.py

@@ -5,9 +5,13 @@ from helper_functions.checkpoint import checkpoint
 
 # get interface design
 from ui.interface_design import interface_init
-
+from langchain_huggingface import HuggingFaceEmbeddings
+import helper_functions.load_embed_model
 
 def main():
+    helper_functions.load_embed_model.embedding_model = HuggingFaceEmbeddings(
+                                                        model_name='sentence-transformers/all-MiniLM-L6-v2'
+                                                        )
     interface_init()
 
 

rag/ifixit_document_retrieval.py

@@ -1,6 +1,6 @@
 
 from langchain_community.document_loaders import IFixitLoader
-from helper_functions.llm_base_client import llm_base_client_init
+from helper_functions.llm_client_initialization import llm_base_client_init
 #function for rewriting info into searchphrase
 def write_searchphrase(search_info: str, debug: bool = False):
     """

rag/vectorization_functions.py

@@ -2,11 +2,10 @@
 #%%
 # General
 from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain_huggingface import HuggingFaceEmbeddings
 from langchain_community.vectorstores import FAISS
-from helper_functions.llm_base_client import llm_base_client_init
+import helper_functions.load_embed_model
 
-def split_documents(documents, chunk_size=800, chunk_overlap=80): # check chunk size and overlap for our purpose
+def split_documents(documents, chunk_size=900, chunk_overlap=90): # check chunk size and overlap for our purpose
     """
     This function splits documents into chunks of given size and overlap.
 
@@ -20,7 +19,8 @@ def split_documents(documents, chunk_size=800, chunk_overlap=80): # check chunk
     """
     text_splitter = RecursiveCharacterTextSplitter(
         chunk_size=chunk_size,
-        chunk_overlap=chunk_overlap
+        chunk_overlap=chunk_overlap,
+        separators=["###", "Step ", "\n\n", "\n", ".", " ", ""] # check separators for our purpose
     )
     chunks = text_splitter.split_documents(documents=documents)
     return chunks
@@ -37,19 +37,16 @@ def create_embedding_vector_db(chunks):
     Returns:
         vector_db: The vector database containing the embedded chunks.
     """
-    # instantiate embedding model
-    embedding = HuggingFaceEmbeddings(
-        model_name='sentence-transformers/all-MiniLM-L6-v2' # EMBEDDING MODEL! converts text to vector ( stick to it)
-    )
     # create the vector store 
-    vector_db = FAISS.from_documents( # stores embeddings # from_documents includes metadata
+    embed_model = helper_functions.load_embed_model.embedding_model # load embedding model
+    vector_database = FAISS.from_documents( # stores embeddings # from_documents includes metadata
         documents=chunks,
-        embedding=embedding
+        embedding=embed_model
     )
-    return vector_db # optimize
+    return vector_database # optimize
 
 # Function to query the vector database and interact with Groq
-def query_vector_db(query, vector_db):
+def query_vector_db(query, vector_db, k):
     """
     This function queries the vector database with the user query and retrieves relevant documents
 
@@ -62,7 +59,7 @@ def query_vector_db(query, vector_db):
 
     """
     # Retrieve relevant documents
-    docs = vector_db.similarity_search(query, k=3) # neigbors k are the chunks # similarity_search: FAISS function
+    docs = vector_db.similarity_search(query, k) # neigbors k are the chunks # similarity_search: FAISS function
     context = "\n".join([doc.page_content for doc in docs])
 
     return context

ui/custom_css.py

@@ -1,5 +1,3 @@
-# Load a custom CSS for Gradio interface
-
 def custom_css():
     """
     Custom CSS for Gradio interface to style buttons, chat container, and background.
@@ -9,6 +7,53 @@ def custom_css():
     """
     custom_css = """
     <style>
+        /* Overall container for Gradio interface */
+        .gradio-container {
+            background-color: #74BA9C !important;
+            display: flex !important;
+            flex-direction: row; /* Make the left and right sections side by side */
+            min-height: 100vh;
+            padding: 20px;
+            box-sizing: border-box;
+            width: 100%;
+            overflow: visible !important;
+        }
+
+        /* Left container for logo, input, and buttons */
+        .gradio-left-container {
+            display: flex;
+            flex-direction: column;
+            width: 40%;  /* Adjust width as needed */
+            padding-right: 20px; /* Space between left and right sections */
+        }
+
+        /* Right container for the chat output */
+        .gradio-right-container {
+            display: flex;
+            flex-direction: column;
+            flex: 1;
+            margin-left: 20px;  /* Space between left and right sections */
+        }
+
+        /* Style the logo */
+        #logo img {
+            width: auto;
+            height: 190px;  /* Adjust the height of the logo */
+            max-width: 100%;
+            margin-bottom: 20px; /* Add margin for spacing between logo and other elements */
+        }
+        
+        #logo {
+             background-color: #ffffff !important;
+        }
+
+        /* Make the input text box expand to fill available space */
+        .input-textbox {
+            flex-grow: 1;
+            height: 100px;
+        }
+
+        /* Submit button style */
         .submit-button {
             background-color: #E69A8D !important; /* Coral Red */
             color: white !important;
@@ -20,21 +65,31 @@ def custom_css():
             cursor: pointer;
             border-radius: 5px;
         }
+
         .submit-button:hover {
             background-color: #D17F73 !important;
         }
-        .chat-container {
-            max-height: 500px;
-            overflow-y: auto;
-        }
+
+        /* Feedback buttons layout */
         .feedback-buttons {
             display: flex;
             gap: 10px;
             margin-top: 5px;
         }
-        .gradio-container {
-            background-color: #74BA9C !important;
+
+        /* Ensure the full page is responsive */
+        body {
+            margin: 0;
+            padding: 0;
+            height: auto;
+            overflow-y: auto;
+        }
+
+        .gradio-row {
+            display: flex;
+            justify-content: flex-start;
+            align-items: flex-start;
         }
     </style>
     """
-    return custom_css
+    return custom_css

ui/interface_design.py

@@ -1,48 +1,79 @@
-
 #%%
-
 import gradio as gr
-from chat_logic.chat_stream import chatbot_interface, feedback_positive, feedback_negative
+from chat_logic.chat_stream import chatbot_interface, feedback_positive, feedback_negative, handle_user_input
 from ui.custom_css import custom_css
 
 def interface_init():
     """
     Initialize the Gradio interface for the Repair Assistant chatbot.
-
     """
-   
+
     logo_path = "./images/logo.png"
 
     # Gradio UI
     with gr.Blocks() as app:
-        gr.Image(logo_path, elem_id="logo", show_label=False)
         gr.HTML(custom_css())  # Insert custom CSS
-        gr.Markdown("### Repair Assistant - Fix smarter with AI")
-        gr.Markdown("State your repair topic, select your response style and start chatting.")
 
-        # 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")
+        # Create a row for the layout
+        with gr.Row():
+            # Left container for the logo, input, and buttons
+            with gr.Column(scale=1, elem_id="gradio-left-container"):
+                # Logo
+                gr.Image(logo_path, elem_id="logo", show_label=False, show_fullscreen_button=False)
 
-        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)
+                response_type = gr.Radio(
+                    ["Simple Language", "Technical", "Homer Simpson Language", "Sarcasm"],
+                    label="Answer Style"
+                )
+                
+                # Feedback section (thumbs up and thumbs down buttons, and markdown)
+                gr.Markdown("🛠️ **Did the repair work?**")
+                with gr.Row(elem_classes="feedback-buttons"):
+                    thumbs_up = gr.Button("👍 Yes")
+                    thumbs_down = gr.Button("👎 No")
+                
+            # Right container for the chat output and feedback buttons
+            with gr.Column(scale=2, elem_id="gradio-right-container"):
+                # Chat history output
 
-        # "Did the repair work?" label
-        gr.Markdown("**Did the repair work?**")
+                # chat_history = gr.State([])  # For maintaining the chat state
+                conversation_state = gr.State("interactive_diagnosis") # For awaiting the users response if support ticket is needed
 
-        # Feedback buttons (not functional yet)
-        with gr.Row(elem_classes="feedback-buttons"):
-            thumbs_up = gr.Button("👍 Yes")
-            thumbs_down = gr.Button("👎 No")
+                chatbot = gr.Chatbot(elem_id="chat-container")
+                
+                # Input components
+                user_input = gr.Textbox(
+                    label="Pick an answer style and let the Repair Assistant help you!",
+                    placeholder="Your input here",
+
+                    elem_classes="input-textbox"
+                )
+                submit_btn = gr.Button("Submit", elem_classes="submit-button")
+
+                submit_btn.click(
+                    fn=handle_user_input,
+                    inputs=[user_input, chatbot, conversation_state, response_type],
+                    outputs=[chatbot, user_input, conversation_state]
+                )
+
+                user_input.submit(
+                    fn=handle_user_input,
+                    inputs=[user_input, chatbot, conversation_state, response_type],
+                    outputs=[chatbot, user_input, conversation_state]
+                )
 
         # 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=[chatbot],
+            outputs=[chatbot, user_input, conversation_state]
+        )
 
-        # Connect thumbs down to continue troubleshooting
-        thumbs_down.click(fn=feedback_negative, inputs=[chat_history], outputs=chatbot)
-        
+        # Connect thumbs down
+        thumbs_down.click(
+            fn=feedback_negative,
+            inputs=[chatbot],
+            outputs=[chatbot, conversation_state]
+        )
+    
     app.queue().launch()
-