added whole program

README.md

@@ -1,13 +1,13 @@
 ---
 title: RepAIr
-emoji: 🐨
+emoji: 🛠️
 colorFrom: green
 colorTo: green
 sdk: gradio
 sdk_version: 5.23.3
-app_file: app.py
+app_file: main.py
 pinned: false
-short_description: Our help bot using iFixit
+short_description: Our help bot using iFixit! :)
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

chat_logic/chat_stream.py

@@ -0,0 +1,126 @@
+#%% 
+# 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
+
+
+def chatbot_interface(history, user_query):
+    """ 
+
+    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()
+
+    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)]  
+
+#%% 
+# 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.
+    
+    """
+    client = llm_base_client_init()
+    answer_prompt = load_prompts(prompt, context)
+    messages = [{"role": "system",
+              "content": answer_prompt}]
+    
+    if memory:
+        for user_msg, bot_msg in memory:
+            messages.append({"role": "user", "content": user_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
+    chat_completion = client.chat.completions.create(
+        messages=messages,
+        model=modelname,
+        temperature=temp
+    )
+    return chat_completion
+
+
+def chatbot_interface(history, user_query):
+    """ 
+
+    LLM Model is defined here.
+    Chat history use and chat with user coded here.
+    
+    """
+
+    # 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")
+        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")
+        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."))
+    return history
+
+# Feedback function for thumbs down (chat continues)
+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

chat_logic/prompts.py

@@ -0,0 +1,20 @@
+def load_prompts(prompt, context=""):
+    """
+    Load the prompts from a file or define them in the code.
+
+    """
+    # You can load these prompts
+
+    if prompt == "default":
+        return """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 prompt == "repair_guide":
+        return (f"List repair steps for the Problem. Use the following context:\n{context}")
+    
+    if prompt == "repair_helper":
+        return (f"Answer the users question about the guide. Use the following context:\n{context}")
+   
+    
+    

helper_functions/checkpoint.py

@@ -0,0 +1,12 @@
+import os
+
+def checkpoint(path):
+    """Prints a message indicating the successful execution of a script.
+    It will give you the script name where this function is calles by default.
+    Alternatively, you can set a string to display a custom message."""
+    
+    script_name = os.path.basename(path)  # Extract just the filename
+    
+    print("-" * 30)
+    print(f"{script_name} successfully executed!")
+    print("-" * 30)

helper_functions/llm_base_client.py

@@ -0,0 +1,12 @@
+#%%
+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
+

main.py

@@ -0,0 +1,20 @@
+#%%
+
+# import checkpoint message
+from helper_functions.checkpoint import checkpoint
+
+# get interface design
+from ui.interface_design import interface_init
+
+
+def main():
+    interface_init()
+
+
+if __name__ == "__main__":
+    main()
+
+checkpoint(__file__)
+
+
+# %%

rag/ifixit_document_retrieval.py

@@ -0,0 +1,74 @@
+
+from langchain_community.document_loaders import IFixitLoader
+from helper_functions.llm_base_client import llm_base_client_init
+#function for rewriting info into searchphrase
+def write_searchphrase(search_info: str, debug: bool = False):
+    """
+    Uses the LLM to rewrite input into a structured searchphrase iFixit searches.
+
+    Args:
+        search_info (str): The information to be turned into a searchphrase.
+    """
+    client = llm_base_client_init()
+    
+    chat_completion = client.chat.completions.create(
+        messages=[
+           {"role": "system",
+             "content": """Rewrite the following info into a structured searchphrase for iFixit, 
+             ensuring it includes in this order the device name, model and part that needs to be repaired. 
+             Return only the searchphrase, do not include any other words or comments.
+             Capitalize the first letter of each word.
+             The searchphrase should be a single sentence."""},
+            {"role": "user", "content": search_info},
+        ],
+        model="llama3-8b-8192",
+        temperature=0.1
+    )
+    search_phrase = chat_completion.choices[0].message.content
+    if debug == True:
+        print('Full searchphrase:', search_phrase)
+    return search_phrase
+
+#load guides from iFixit
+def load_guides(search_phrase: str, debug: bool = False):
+    """
+    Load a guide from IFixit based on the search phrase.
+    If no guide is found, iteratively remove the last word and retry.
+    
+    Args:
+        search_phrase (str): The phrase to search for in IFixit guides.
+        
+    Returns:
+        guides: The loaded guide data or None if no guide is found.
+    """
+    words = search_phrase.split()
+    
+    while words:
+        query = " ".join(words)
+        guides = IFixitLoader.load_suggestions(query, doc_type='guide')
+        
+        if guides:
+            if(debug == True):
+                print('Used words:', words)
+            return guides  # Return results if found
+        
+        words.pop()  # Remove the last word and retry
+
+    print('No guides found')
+    return None  # Return None if no guide is found
+
+def load_ifixit_guides(search_info: str, debug: bool = False):
+    """
+
+    Rewrites the search info into a searchphrase and loads guides from iFixit.
+
+    Args:
+        search info (str): The information to be turned into a searchphrase.
+        
+    Returns:
+        guides: The loaded guide data or None if no guide is found.
+
+    """
+    search_phrase = write_searchphrase(search_info, debug=debug)
+    guides = load_guides(search_phrase, debug=debug)
+    return guides

rag/vectorization_functions.py

@@ -0,0 +1,57 @@
+# vectorization functions
+#%%
+# 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
+
+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
+    """
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=chunk_size,
+        chunk_overlap=chunk_overlap
+    )
+    chunks = text_splitter.split_documents(documents=documents)
+    return chunks
+
+def create_embedding_vector_db(chunks #, db_name, target_directory=f"../vector_databases"
+                               ):
+    """
+    this function 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
+    """
+    # 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
+        documents=chunks,
+        embedding=embedding
+    )
+    return vector_db # optimize
+
+#Function to query the vector database and interact with Groq
+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
+    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

requirements.txt

@@ -0,0 +1,27 @@
+black==23.3.0
+faiss-cpu==1.10.0
+jupyterlab==4.2.5
+langchain-community==0.3.20
+langchain-groq==0.2.0
+langchain-huggingface==0.1.0
+langchain-openai==0.2.3
+langchainhub==0.1.21
+matplotlib==3.7.1
+numpy==1.26.4
+pandas==2.0.1
+parsenvy==3.0.2
+protobuf==4.23.3
+pypdf==4.2.0
+python-dotenv==1.0.1
+seaborn==0.11.2
+scikit-learn==1.2.2
+statsmodels==0.14.0
+pytest==7.4.0
+testbook==0.4.2
+gradio
+
+
+
+
+
+

ui/custom_css.py

@@ -0,0 +1,30 @@
+
+def custom_css():
+    custom_css = """
+    <style>
+        .submit-button {
+            background-color: #E69A8D !important; /* Coral Red */
+            color: white !important;
+            border: none;
+            padding: 10px 20px;
+            text-align: center;
+            font-size: 16px;
+            margin: 4px 2px;
+            cursor: pointer;
+            border-radius: 5px;
+        }
+        .submit-button:hover {
+            background-color: #D17F73 !important;
+        }
+        .chat-container {
+            max-height: 500px;
+            overflow-y: auto;
+        }
+        .feedback-buttons {
+            display: flex;
+            gap: 10px;
+            margin-top: 5px;
+        }
+    </style>
+    """
+    return custom_css

ui/interface_design.py

@@ -0,0 +1,62 @@
+
+#%%
+
+
+#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():
+   
+    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.")
+
+        # 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.")
+        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])
+
+        # "Did the repair work?" label
+        gr.Markdown("**Did the repair work?**")
+
+        # Feedback buttons
+        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)
+
+        # Connect thumbs down to continue troubleshooting
+       # thumbs_down.click(fn=feedback_negative, inputs=[chat_history], outputs=chatbot)
+    app.queue().launch()
+
+# %%