Update app.py

app.py

@@ -11,6 +11,10 @@ import aiohttp
 import re
 import base64
 import logging
+import os
+
+# Import Hugging Face transformers
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 
 # Set up logging
 logging.basicConfig(filename='app.log', level=logging.INFO,
@@ -50,6 +54,12 @@ CATEGORIES = [
     "Uncategorized",
 ]
 
+# Load FLAN-T5 model and tokenizer
+logger.info("Loading FLAN-T5 model and tokenizer")
+tokenizer = AutoTokenizer.from_pretrained('google/flan-t5-small')
+model = AutoModelForSeq2SeqLM.from_pretrained('google/flan-t5-small')
+
+# Function to parse bookmarks from HTML
 def parse_bookmarks(file_content):
     logger.info("Parsing bookmarks")
     try:
@@ -66,6 +76,7 @@ def parse_bookmarks(file_content):
         logger.error("Error parsing bookmarks: %s", e)
         raise
 
+# Asynchronous function to fetch URL info
 async def fetch_url_info(session, bookmark):
     url = bookmark['url']
     if url in fetch_cache:
@@ -114,6 +125,7 @@ async def fetch_url_info(session, bookmark):
         }
     return bookmark
 
+# Asynchronous processing of bookmarks
 async def process_bookmarks_async(bookmarks):
     logger.info("Processing bookmarks asynchronously")
     try:
@@ -128,6 +140,7 @@ async def process_bookmarks_async(bookmarks):
         logger.error(f"Error in asynchronous processing of bookmarks: {e}")
         raise
 
+# Generate summary for a bookmark
 def generate_summary(bookmark):
     description = bookmark.get('description', '')
     if description:
@@ -141,6 +154,7 @@ def generate_summary(bookmark):
     logger.info(f"Generated summary for bookmark: {bookmark.get('url')}")
     return bookmark
 
+# Assign category to a bookmark
 def assign_category(bookmark):
     if bookmark.get('dead_link'):
         bookmark['category'] = 'Dead Link'
@@ -188,6 +202,7 @@ def assign_category(bookmark):
         logger.info(f"No matching category found for bookmark: {bookmark.get('url')}")
     return bookmark
 
+# Vectorize summaries and build FAISS index
 def vectorize_and_index(bookmarks):
     logger.info("Vectorizing summaries and building FAISS index")
     try:
@@ -202,6 +217,7 @@ def vectorize_and_index(bookmarks):
         logger.error(f"Error in vectorizing and indexing: {e}")
         raise
 
+# Generate HTML display for bookmarks
 def display_bookmarks():
     logger.info("Generating HTML display for bookmarks")
     cards = ''
@@ -238,6 +254,7 @@ def display_bookmarks():
     logger.info("HTML display generated")
     return cards
 
+# Process the uploaded file
 def process_uploaded_file(file):
     global bookmarks, faiss_index
     logger.info("Processing uploaded file")
@@ -283,30 +300,38 @@ def process_uploaded_file(file):
     bookmark_html = display_bookmarks()
     return message, bookmark_html
 
+# Chatbot response using Hugging Face model
 def chatbot_response(user_query):
-    if faiss_index is None or not bookmarks:
+    if not bookmarks:
         logger.warning("No bookmarks available for chatbot")
         return "No bookmarks available. Please upload and process your bookmarks first."
 
     logger.info(f"Chatbot received query: {user_query}")
-    # Vectorize user query
+
+    # Prepare the context
     try:
-        user_embedding = embedding_model.encode([user_query])
-        D, I = faiss_index.search(np.array(user_embedding), k=5)  # Retrieve top 5 matches
+        # Combine bookmark summaries into context
+        max_bookmarks = 50  # Adjust as needed
+        bookmark_context = ""
+        for idx, bookmark in enumerate(bookmarks[:max_bookmarks]):
+            bookmark_context += f"{idx+1}. Title: {bookmark['title']}\nSummary: {bookmark['summary']}\n\n"
+
+        # Construct the prompt
+        prompt = f"Based on the following bookmarks, answer the user's query.\n\nUser query: {user_query}\n\nBookmarks:\n{bookmark_context}"
+
+        # Generate response
+        inputs = tokenizer(prompt, return_tensors='pt', max_length=512, truncation=True)
+        outputs = model.generate(**inputs, max_length=512)
+        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+        logger.info("Chatbot response generated using FLAN-T5 model")
+        return generated_text.strip()
+
     except Exception as e:
-        logger.error(f"Error in chatbot vectorization or search: {e}")
+        logger.error(f"Error in chatbot response generation: {e}")
         return "Error processing your query."
 
-    # Generate response
-    response = ""
-    for idx in I[0]:
-        if idx < len(bookmarks):
-            bookmark = bookmarks[idx]
-            index = idx + 1  # Start index at 1
-            response += f"{index}. Title: {bookmark['title']}\nURL: {bookmark['url']}\nCategory: {bookmark.get('category', 'Uncategorized')}\nSummary: {bookmark['summary']}\n\n"
-    logger.info("Chatbot response generated")
-    return response.strip()
-
+# Edit a bookmark
 def edit_bookmark(bookmark_idx, new_title, new_url, new_category):
     global faiss_index
     try:
@@ -331,6 +356,7 @@ def edit_bookmark(bookmark_idx, new_title, new_url, new_category):
         logger.error(f"Error editing bookmark: {e}")
         return f"Error: {str(e)}", display_bookmarks()
 
+# Delete selected bookmarks
 def delete_bookmarks(indices_str):
     global faiss_index
     try:
@@ -354,6 +380,7 @@ def delete_bookmarks(indices_str):
         logger.error(f"Error deleting bookmarks: {e}")
         return f"Error: {str(e)}", display_bookmarks()
 
+# Export bookmarks to HTML
 def export_bookmarks():
     if not bookmarks:
         logger.warning("No bookmarks to export")
@@ -380,6 +407,7 @@ def export_bookmarks():
         logger.error(f"Error exporting bookmarks: {e}")
         return None
 
+# Build the Gradio app
 def build_app():
     logger.info("Building Gradio app")
     with gr.Blocks(css="app.css") as demo: