Update app.py

app.py

@@ -1,92 +1,96 @@
 from huggingface_hub import InferenceClient
+
+#step 1 from semantic search
 from sentence_transformers import SentenceTransformer
 import torch
 import gradio as gr
-import requests
-import os
-TMDB_TOKEN = os.getenv("TMDB_BEARER_TOKEN")
+import random
 
-# Hugging Face model
 client = InferenceClient("Qwen/Qwen2.5-72B-Instruct")
-
-# Load and clean reconext text
+#step 2 from semantic search read file
+# Open the water_cycle.txt file in read mode with UTF-8 encoding
 with open("reconext_file.txt", "r", encoding="utf-8") as file:
-    reconext_file_text = file.read()
-
+  # 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
 def preprocess_text(text):
-    chunks = [chunk.strip() for chunk in text.strip().split("\n") if chunk.strip()]
-    return chunks
-
-cleaned_chunks = preprocess_text(reconext_file_text)
-
-# Convert text chunks to embeddings
+  # 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
 model = SentenceTransformer('all-MiniLM-L6-v2')
-
 def create_embeddings(text_chunks):
-    return model.encode(text_chunks, convert_to_tensor=True)
-
-chunk_embeddings = create_embeddings(cleaned_chunks)
-
-# Semantic search for top relevant 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
 def get_top_chunks(query, chunk_embeddings, text_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
-    return [text_chunks[i] for i in top_indices]
-
-# TMDB API function
-def get_tmdb_recommendation(query):
-    url = "https://api.themoviedb.org/3/search/multi"
-    headers = {
-        "Authorization": f"Bearer {TMDB_BEARER_TOKEN}"
-    }
-    params = {
-        "query": query,
-        "include_adult": False,
-        "language": "en-US",
-        "page": 1
-    }
-
-    response = requests.get(url, headers=headers, params=params)
-    if response.status_code == 200:
-        results = response.json().get("results", [])
-        if not results:
-            return "Nothin' popped up on TMDB for that 🫠"
-        
-        top = results[0]
-        title = top.get("title") or top.get("name") or "a mystery show"
-        overview = top.get("overview", "No description available.")
-        return f"🔥 Try watching **{title}** — {overview}"
-    else:
-        return "TMDB ghosted us 👻 Try again later."
-
-# Chatbot response function
+  # 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
 def respond(message, history):
-    if any(word in message.lower() for word in ["recommend", "suggest", "watch", "movie", "show"]):
-        return get_tmdb_recommendation(message)
-
-    best_chunks = get_top_chunks(message, chunk_embeddings, cleaned_chunks)
-    str_chunks = "\n".join(best_chunks)
-
+    best_next_watch = get_top_chunks(message, chunk_embeddings, cleaned_chunks)
+    print(best_next_watch)
+    str_watch_chunks = "\n".join(best_next_watch)
     messages = [
-        {
-            "role": "system",
-            "content": f"You are a gen-z helpful chatbot that helps teenagers find their next best watch as in TV shows and movies. Speak in a chill, funny, and relatable tone, but not too long of replies. Use the info below to answer:\n{str_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. You should answer the users question based on " + 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()
-
-# Gradio app
-chatbot = gr.ChatInterface(respond, title="📺 Gen-Z Watch Buddy")
-chatbot.launch()
+chatbot = gr.ChatInterface(respond, type="messages")
+chatbot.launch()