Update app.py

app.py

@@ -1,131 +1,92 @@
-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
+import requests
+import os
+TMDB_TOKEN = os.getenv("TMDB_BEARER_TOKEN")
 
+# Hugging Face model
 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
+# Load and clean reconext text
 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))
+    chunks = [chunk.strip() for chunk in text.strip().split("\n") if chunk.strip()]
+    return chunks
 
-  # Return the cleaned_chunks
-  return cleaned_chunks
+cleaned_chunks = preprocess_text(reconext_file_text)
 
-# 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
+# Convert text chunks to embeddings
 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 model.encode(text_chunks, convert_to_tensor=True)
 
-  # Return the chunk_embeddings
-  return chunk_embeddings
+chunk_embeddings = create_embeddings(cleaned_chunks)
 
-# 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
+# Semantic search for top relevant chunks
 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
+    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_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
+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)
 
-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)
     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": f"You are a gen-z helpful chatbot that helps teenagers find their next best watch. Speak in a chill, funny, and relatable tone. Use the info below to answer:\n{str_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()
+# Gradio app
+chatbot = gr.ChatInterface(respond, title="📺 Gen-Z Watch Buddy")
+chatbot.launch()