Update app.py

app.py

@@ -1,96 +1,97 @@
-from huggingface_hub import InferenceClient
-
-#step 1 from semantic search
+from huggingface_hub import InferenceClient 
 from sentence_transformers import SentenceTransformer
 import torch
 import gradio as gr
-import random
 
+# Initialize the Hugging Face Inference Client
 client = InferenceClient("Qwen/Qwen2.5-72B-Instruct")
-#step 2 from semantic search read file
-# Open the water_cycle.txt file in read mode with UTF-8 encoding
+
+# Step 1: Load and preprocess the context file
 with open("reconext_file.txt", "r", encoding="utf-8") as file:
-  # Read the entire contents of the file and store it in a variable
-  reconext_file_text = file.read()
-# Print the text below
-print(reconext_file_text)
-#step 3 from semantix search
+    reconext_file_text = file.read()
+
 def preprocess_text(text):
-  # Strip extra whitespace from the beginning and the end of the text
-  cleaned_text = text.strip()
-  # Split the cleaned_text by every newline character (\n)
-  chunks = cleaned_text.split("\n")
-  # Create an empty list to store cleaned chunks
-  cleaned_chunks = []
-  # Write your for-in loop below to clean each chunk and add it to the cleaned_chunks list
-  for chunk in chunks:
-    clean_chunk = chunk.strip()
-    if(len(clean_chunk) >= 0):
-      cleaned_chunks.append(clean_chunk)
-  # Print cleaned_chunks
-  print(cleaned_chunks)
-  # Print the length of cleaned_chunks
-  print(len(cleaned_chunks))
-  # Return the cleaned_chunks
-  return cleaned_chunks
-# Call the preprocess_text function and store the result in a cleaned_chunks variable
-cleaned_chunks = preprocess_text(reconext_file_text) # Complete this line
-#step 4 from semantic search
-# Load the pre-trained embedding model that converts text to vectors
+    cleaned_text = text.strip()
+    chunks = cleaned_text.split("\n")
+    cleaned_chunks = [chunk.strip() for chunk in chunks if len(chunk.strip()) > 0]
+    return cleaned_chunks
+
+cleaned_chunks = preprocess_text(reconext_file_text)
+
+# Step 2: Create embeddings for the text chunks
 model = SentenceTransformer('all-MiniLM-L6-v2')
+
 def create_embeddings(text_chunks):
-  # Convert each text chunk into a vector embedding and store as a tensor
-  chunk_embeddings = model.encode(text_chunks, convert_to_tensor=True) # Replace ... with the text_chunks list
-  # Print the chunk embeddings
-  print(chunk_embeddings)
-  # Print the shape of chunk_embeddings
-  print(chunk_embeddings.shape)
-  # Return the chunk_embeddings
-  return chunk_embeddings
-# Call the create_embeddings function and store the result in a new chunk_embeddings variable
-chunk_embeddings = create_embeddings(cleaned_chunks) # Complete this line
-#step 5 from semantic search
-# Define a function to find the most relevant text chunks for a given query, chunk_embeddings, and text_chunks
+    chunk_embeddings = model.encode(text_chunks, convert_to_tensor=True)
+    return chunk_embeddings
+
+chunk_embeddings = create_embeddings(cleaned_chunks)
+
+# Step 3: Semantic search to get relevant chunks for a user query
 def get_top_chunks(query, chunk_embeddings, text_chunks):
-  # Convert the query text into a vector embedding
-  query_embedding = model.encode(query, convert_to_tensor=True) # Complete this line
-  # Normalize the query embedding to unit length for accurate similarity comparison
-  query_embedding_normalized = query_embedding / query_embedding.norm()
-  # Normalize all chunk embeddings to unit length for consistent comparison
-  chunk_embeddings_normalized = chunk_embeddings / chunk_embeddings.norm(dim=1, keepdim=True)
-  # Calculate cosine similarity between query and all chunks using matrix multiplication
-  similarities = torch.matmul(chunk_embeddings_normalized, query_embedding_normalized) # Complete this line
-  # Print the similarities
-  print(similarities)
-  # Find the indices of the 3 chunks with highest similarity scores
-  top_indices = torch.topk(similarities, k=3).indices
-  # Print the top indices
-  print(top_indices)
-  # Create an empty list to store the most relevant chunks
-  top_chunks = []
-  # Loop through the top indices and retrieve the corresponding text chunks
-  for i in top_indices:
-    top_chunks.append(text_chunks[i])
-  # Return the list of most relevant chunks
-  return top_chunks
+    query_embedding = model.encode(query, convert_to_tensor=True)
+    query_embedding_normalized = query_embedding / query_embedding.norm()
+    chunk_embeddings_normalized = chunk_embeddings / chunk_embeddings.norm(dim=1, keepdim=True)
+    similarities = torch.matmul(chunk_embeddings_normalized, query_embedding_normalized)
+    top_indices = torch.topk(similarities, k=3).indices
+    top_chunks = [text_chunks[i] for i in top_indices]
+    return top_chunks
+
+# Step 4: Generate a response using the Hugging Face model
 def respond(message, history):
     best_next_watch = get_top_chunks(message, chunk_embeddings, cleaned_chunks)
-    print(best_next_watch)
     str_watch_chunks = "\n".join(best_next_watch)
+
+    # Build messages for prompt
     messages = [
-        {"role":"system",
-        "content": "You are a gen-z helpful chatbot that helps teenagers find their next best watch, speak in gen-z terms and be natural. You should answer the users question based on " + str_watch_chunks + " ."
+        {
+            "role": "system",
+            "content": (
+                "You are a gen-z helpful chatbot that helps teenagers find their next best watch. "
+                "Speak in gen-z terms and be natural. Answer the user's question based on:\n" + str_watch_chunks
+            )
         }
     ]
     if history:
         messages.extend(history)
-    messages.append(
-        {'role':'user',
-        'content':message}
-    )
+
+    messages.append({"role": "user", "content": message})
+
     response = client.chat_completion(
-        messages, max_tokens = 300, temperature=1.3, top_p=0.6
+        messages, max_tokens=300, temperature=1.3, top_p=0.6
     )
     return response['choices'][0]['message']['content'].strip()
-chatbot = gr.ChatInterface(respond, type="messages")
-chatbot.launch()
+
+# Step 5: Create the Gradio interface
+with gr.Blocks() as demo:
+    chatbot = gr.Chatbot()
+    msg = gr.Textbox(placeholder="Ask me what to watch...", label="Your Message")
+    state = gr.State([])  # Track conversation history
+
+    # Initial assistant message
+    def startup():
+        greeting = (
+            "Yo! I'm your binge buddy. 🎬🔥 Just tell me what vibe you're feelin' "
+            "and I’ll hook you up with the next thing to watch. Let's get it!"
+        )
+        return [("", greeting)], [{"role": "assistant", "content": greeting}]
+
+    # Chat handler
+    def user_message(message, history):
+        bot_response = respond(message, history)
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": bot_response})
+
+        # Format history for display in Chatbot
+        display = []
+        for i in range(1, len(history), 2):
+            display.append((history[i-1]["content"], history[i]["content"]))
+        return display, history
+
+    # Load initial greeting
+    demo.load(startup, outputs=[chatbot, state])
+
+    # Respond to user input
+    msg.submit(fn=user_message, inputs=[msg, state], outputs=[chatbot, state])
+
+demo.launch()