Update app.py

app.py

@@ -19,6 +19,10 @@ import threading
 # Import OpenAI library
 import openai
 
+# Suppress only the single warning from urllib3 needed.
+import urllib3
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
 # Set up logging to output to the console
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
@@ -34,8 +38,8 @@ console_handler.setFormatter(formatter)
 # Add the handler to the logger
 logger.addHandler(console_handler)
 
-# Initialize models and variables
-logger.info("Initializing models and variables")
+# Initialize variables and models
+logger.info("Initializing variables and models")
 embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
 faiss_index = None
 bookmarks = []
@@ -77,7 +81,11 @@ if not GROQ_API_KEY:
     logger.error("GROQ_API_KEY environment variable not set.")
 
 openai.api_key = GROQ_API_KEY
-openai.api_base = "https://api.groq.com/openai/v1"
+openai.api_base = "https://api.groq.com/openai/v1"  # Ensure this is the correct base URL
+
+# Initialize global variables for rate limiting
+api_lock = threading.Lock()
+last_api_call_time = 0
 
 def extract_main_content(soup):
     """
@@ -159,12 +167,20 @@ def generate_summary_and_assign_category(bookmark):
 
     while retry_count < max_retries:
         try:
+            # Rate Limiting Logic
+            with api_lock:
+                global last_api_call_time
+                current_time = time.time()
+                elapsed = current_time - last_api_call_time
+                if elapsed < 2:
+                    sleep_duration = 2 - elapsed
+                    logger.info(f"Sleeping for {sleep_duration:.2f} seconds to respect rate limits.")
+                    time.sleep(sleep_duration)
+                last_api_call_time = time.time()
+
+            # Existing logic to prepare the prompt
             html_content = bookmark.get('html_content', '')
-
-            # Get the HTML soup object from the bookmark
             soup = BeautifulSoup(html_content, 'html.parser')
-
-            # Extract metadata and main content
             metadata = get_page_metadata(soup)
             main_content = extract_main_content(soup)
 
@@ -226,14 +242,14 @@ Category: [One category]
                 return len(text) / 4  # Approximate token estimation
 
             prompt_tokens = estimate_tokens(prompt)
-            max_tokens = 150  # Reduced from 200
+            max_tokens = 150  # Adjusted from 200
             total_tokens = prompt_tokens + max_tokens
 
             # Calculate required delay
-            tokens_per_minute = 60000  # Adjust based on your rate limit
+            tokens_per_minute = 40000
             tokens_per_second = tokens_per_minute / 60
             required_delay = total_tokens / tokens_per_second
-            sleep_time = max(required_delay, 1)
+            sleep_time = max(required_delay, 2)  # Ensure at least 2 seconds
 
             # Call the LLM via Groq Cloud API
             response = openai.ChatCompletion.create(
@@ -244,6 +260,7 @@ Category: [One category]
                 max_tokens=int(max_tokens),
                 temperature=0.5,
             )
+
             content = response['choices'][0]['message']['content'].strip()
             if not content:
                 raise ValueError("Empty response received from the model.")
@@ -281,7 +298,7 @@ Category: [One category]
         except openai.error.RateLimitError as e:
             retry_count += 1
             wait_time = int(e.headers.get("Retry-After", 5))
-            logger.warning(f"Rate limit reached. Waiting for {wait_time} seconds before retrying...")
+            logger.warning(f"Rate limit reached. Waiting for {wait_time} seconds before retrying... (Attempt {retry_count}/{max_retries})")
             time.sleep(wait_time)
         except Exception as e:
             logger.error(f"Error generating summary and assigning category: {e}", exc_info=True)
@@ -377,6 +394,7 @@ def vectorize_and_index(bookmarks_list):
     """
     Create vector embeddings for bookmarks and build FAISS index with ID mapping.
     """
+    global faiss_index
     logger.info("Vectorizing summaries and building FAISS index")
     try:
         summaries = [bookmark['summary'] for bookmark in bookmarks_list]
@@ -386,6 +404,7 @@ def vectorize_and_index(bookmarks_list):
         # Assign unique IDs to each bookmark
         ids = np.array([bookmark['id'] for bookmark in bookmarks_list], dtype=np.int64)
         index.add_with_ids(np.array(embeddings).astype('float32'), ids)
+        faiss_index = index
         logger.info("FAISS index built successfully with IDs")
         return index
     except Exception as e:
@@ -441,7 +460,7 @@ def display_bookmarks():
     logger.info("HTML display generated")
     return cards
 
-def process_uploaded_file(file):
+def process_uploaded_file(file, state_bookmarks):
     """
     Process the uploaded bookmarks file.
     """
@@ -450,23 +469,23 @@ def process_uploaded_file(file):
 
     if file is None:
         logger.warning("No file uploaded")
-        return "Please upload a bookmarks HTML file.", '', gr.update(choices=[]), display_bookmarks()
+        return "Please upload a bookmarks HTML file.", '', state_bookmarks, display_bookmarks()
 
     try:
         file_content = file.decode('utf-8')
     except UnicodeDecodeError as e:
         logger.error(f"Error decoding the file: {e}", exc_info=True)
-        return "Error decoding the file. Please ensure it's a valid HTML file.", '', gr.update(choices=[]), display_bookmarks()
+        return "Error decoding the file. Please ensure it's a valid HTML file.", '', state_bookmarks, display_bookmarks()
 
     try:
         bookmarks = parse_bookmarks(file_content)
     except Exception as e:
         logger.error(f"Error parsing bookmarks: {e}", exc_info=True)
-        return "Error parsing the bookmarks HTML file.", '', gr.update(choices=[]), display_bookmarks()
+        return "Error parsing the bookmarks HTML file.", '', state_bookmarks, display_bookmarks()
 
     if not bookmarks:
         logger.warning("No bookmarks found in the uploaded file")
-        return "No bookmarks found in the uploaded file.", '', gr.update(choices=[]), display_bookmarks()
+        return "No bookmarks found in the uploaded file.", '', state_bookmarks, display_bookmarks()
 
     # Assign unique IDs to bookmarks
     for idx, bookmark in enumerate(bookmarks):
@@ -474,19 +493,19 @@ def process_uploaded_file(file):
 
     # Fetch bookmark info concurrently
     logger.info("Fetching URL info concurrently")
-    with ThreadPoolExecutor(max_workers=20) as executor:
+    with ThreadPoolExecutor(max_workers=10) as executor:  # Adjusted max_workers as needed
         executor.map(fetch_url_info, bookmarks)
 
     # Process bookmarks concurrently with LLM calls
     logger.info("Processing bookmarks with LLM concurrently")
-    with ThreadPoolExecutor(max_workers=5) as executor:
+    with ThreadPoolExecutor(max_workers=1) as executor:  # Reduced max_workers to 1 to serialize API calls
         executor.map(generate_summary_and_assign_category, bookmarks)
 
     try:
         faiss_index = vectorize_and_index(bookmarks)
     except Exception as e:
         logger.error(f"Error building FAISS index: {e}", exc_info=True)
-        return "Error building search index.", '', gr.update(choices=[]), display_bookmarks()
+        return "Error building search index.", '', state_bookmarks, display_bookmarks()
 
     message = f"✅ Successfully processed {len(bookmarks)} bookmarks."
     logger.info(message)
@@ -496,9 +515,12 @@ def process_uploaded_file(file):
     choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})"
                for i, bookmark in enumerate(bookmarks)]
 
-    return message, bookmark_html, gr.update(choices=choices), bookmark_html
+    # Update state
+    state_bookmarks = bookmarks.copy()
+
+    return message, bookmark_html, state_bookmarks, bookmark_html
 
-def delete_selected_bookmarks(selected_indices):
+def delete_selected_bookmarks(selected_indices, state_bookmarks):
     """
     Delete selected bookmarks and remove their vectors from the FAISS index.
     """
@@ -529,16 +551,19 @@ def delete_selected_bookmarks(selected_indices):
     choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})"
                for i, bookmark in enumerate(bookmarks)]
 
+    # Update state
+    state_bookmarks = bookmarks.copy()
+
     return message, gr.update(choices=choices), display_bookmarks()
 
-def edit_selected_bookmarks_category(selected_indices, new_category):
+def edit_selected_bookmarks_category(selected_indices, new_category, state_bookmarks):
     """
     Edit category of selected bookmarks.
     """
     if not selected_indices:
-        return "⚠️ No bookmarks selected.", gr.update(choices=[]), display_bookmarks()
+        return "⚠️ No bookmarks selected.", gr.update(choices=[]), display_bookmarks(), state_bookmarks
     if not new_category:
-        return "⚠️ No new category selected.", gr.update(choices=[]), display_bookmarks()
+        return "⚠️ No new category selected.", gr.update(choices=[]), display_bookmarks(), state_bookmarks
 
     indices = [int(s.split('.')[0])-1 for s in selected_indices]
     for idx in indices:
@@ -553,7 +578,10 @@ def edit_selected_bookmarks_category(selected_indices, new_category):
     choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})"
                for i, bookmark in enumerate(bookmarks)]
 
-    return message, gr.update(choices=choices), display_bookmarks()
+    # Update state
+    state_bookmarks = bookmarks.copy()
+
+    return message, gr.update(choices=choices), display_bookmarks(), state_bookmarks
 
 def export_bookmarks():
     """
@@ -591,16 +619,25 @@ def chatbot_response(user_query, chat_history):
     """
     if not bookmarks or faiss_index is None:
         logger.warning("No bookmarks available for chatbot")
-        chat_history.append((user_query, "⚠️ No bookmarks available. Please upload and process your bookmarks first."))
+        chat_history.append({"role": "assistant", "content": "⚠️ No bookmarks available. Please upload and process your bookmarks first."})
         return chat_history
 
     logger.info(f"Chatbot received query: {user_query}")
 
     try:
-        # Encode the user query
+        # Rate Limiting Logic
+        with api_lock:
+            global last_api_call_time
+            current_time = time.time()
+            elapsed = current_time - last_api_call_time
+            if elapsed < 2:
+                sleep_duration = 2 - elapsed
+                logger.info(f"Sleeping for {sleep_duration:.2f} seconds to respect rate limits.")
+                time.sleep(sleep_duration)
+            last_api_call_time = time.time()
+
+        # Existing logic to encode the query and search the FAISS index
         query_vector = embedding_model.encode([user_query]).astype('float32')
-
-        # Search the FAISS index
         k = 5  # Number of results to return
         distances, ids = faiss_index.search(query_vector, k)
         ids = ids.flatten()
@@ -611,7 +648,7 @@ def chatbot_response(user_query, chat_history):
 
         if not matching_bookmarks:
             answer = "No relevant bookmarks found for your query."
-            chat_history.append((user_query, answer))
+            chat_history.append({"role": "assistant", "content": answer})
             return chat_history
 
         # Format the response
@@ -638,11 +675,12 @@ Provide a concise and helpful response.
         total_tokens = prompt_tokens + max_tokens
 
         # Calculate required delay
-        tokens_per_minute = 60000  # Adjust based on your rate limit
+        tokens_per_minute = 40000
         tokens_per_second = tokens_per_minute / 60
         required_delay = total_tokens / tokens_per_second
-        sleep_time = max(required_delay, 1)
+        sleep_time = max(required_delay, 2)  # Ensure at least 2 seconds
 
+        # Call the LLM via Groq Cloud API
         response = openai.ChatCompletion.create(
             model='llama-3.1-70b-versatile',  # Using the specified model
             messages=[
@@ -651,12 +689,13 @@ Provide a concise and helpful response.
             max_tokens=int(max_tokens),
             temperature=0.7,
         )
+
         answer = response['choices'][0]['message']['content'].strip()
         logger.info("Chatbot response generated")
         time.sleep(sleep_time)
 
         # Append the interaction to chat history
-        chat_history.append((user_query, answer))
+        chat_history.append({"role": "assistant", "content": answer})
         return chat_history
 
     except openai.error.RateLimitError as e:
@@ -667,7 +706,7 @@ Provide a concise and helpful response.
     except Exception as e:
         error_message = f"⚠️ Error processing your query: {str(e)}"
         logger.error(error_message, exc_info=True)
-        chat_history.append((user_query, error_message))
+        chat_history.append({"role": "assistant", "content": error_message})
         return chat_history
 
 def build_app():
@@ -677,53 +716,119 @@ def build_app():
     try:
         logger.info("Building Gradio app")
         with gr.Blocks(css="app.css") as demo:
+            # Initialize state
+            state_bookmarks = gr.State([])
+
             # General Overview
             gr.Markdown("""
-            # 📚 SmartMarks - AI Browser Bookmarks Manager
-            Welcome to **SmartMarks**, your intelligent assistant for managing browser bookmarks. SmartMarks leverages AI to help you organize, search, and interact with your bookmarks seamlessly.
-            ---
-            ## 🚀 **How to Use SmartMarks**
-            SmartMarks is divided into three main sections:
-            1. **📂 Upload and Process Bookmarks:** Import your existing bookmarks and let SmartMarks analyze and categorize them for you.
-            2. **💬 Chat with Bookmarks:** Interact with your bookmarks using natural language queries to find relevant links effortlessly.
-            3. **🛠️ Manage Bookmarks:** View, edit, delete, and export your bookmarks with ease.
-            """)
+# 📚 SmartMarks - AI Browser Bookmarks Manager
+
+Welcome to **SmartMarks**, your intelligent assistant for managing browser bookmarks. SmartMarks leverages AI to help you organize, search, and interact with your bookmarks seamlessly.
+
+---
+
+## 🚀 **How to Use SmartMarks**
+
+SmartMarks is divided into three main sections:
+
+1. **📂 Upload and Process Bookmarks:** Import your existing bookmarks and let SmartMarks analyze and categorize them for you.
+2. **💬 Chat with Bookmarks:** Interact with your bookmarks using natural language queries to find relevant links effortlessly.
+3. **🛠️ Manage Bookmarks:** View, edit, delete, and export your bookmarks with ease.
+
+Navigate through the tabs to explore each feature in detail.
+""")
 
             # Upload and Process Bookmarks Tab
             with gr.Tab("Upload and Process Bookmarks"):
                 gr.Markdown("""
-                ## 📂 **Upload and Process Bookmarks**
-                ### 📝 **Steps:**
-                1. Click on the "Upload Bookmarks HTML File" button
-                2. Select your bookmarks file
-                3. Click "Process Bookmarks" to analyze and organize your bookmarks
-                """)
+## 📂 **Upload and Process Bookmarks**
+
+### 📝 **Steps to Upload and Process:**
+
+1. **Upload Bookmarks File:**
+   - Click on the **"📁 Upload Bookmarks HTML File"** button.
+   - Select your browser's exported bookmarks HTML file from your device.
+
+2. **Process Bookmarks:**
+   - After uploading, click on the **"⚙️ Process Bookmarks"** button.
+   - SmartMarks will parse your bookmarks, fetch additional information, generate summaries, and categorize each link based on predefined categories.
+
+3. **View Processed Bookmarks:**
+   - Once processing is complete, your bookmarks will be displayed in an organized and visually appealing format below.
+""")
 
                 upload = gr.File(label="📁 Upload Bookmarks HTML File", type='binary')
                 process_button = gr.Button("⚙️ Process Bookmarks")
                 output_text = gr.Textbox(label="✅ Output", interactive=False)
                 bookmark_display = gr.HTML(label="📄 Processed Bookmarks")
 
+                process_button.click(
+                    process_uploaded_file,
+                    inputs=[upload, state_bookmarks],
+                    outputs=[output_text, bookmark_display, state_bookmarks, bookmark_display]
+                )
+
             # Chat with Bookmarks Tab
             with gr.Tab("Chat with Bookmarks"):
                 gr.Markdown("""
-                ## 💬 **Chat with Bookmarks**
-                Ask questions about your bookmarks and get relevant results.
-                """)
+## 💬 **Chat with Bookmarks**
 
-                chatbot = gr.Chatbot(label="💬 Chat with SmartMarks")
+### 🤖 **How to Interact:**
+
+1. **Enter Your Query:**
+   - In the **"✍️ Ask about your bookmarks"** textbox, type your question or keyword related to your bookmarks. For example, "Do I have any bookmarks about GenerativeAI?"
+
+2. **Submit Your Query:**
+   - Click the **"📨 Send"** button to submit your query.
+
+3. **Receive AI-Driven Responses:**
+   - SmartMarks will analyze your query and provide relevant bookmarks that match your request, making it easier to find specific links without manual searching.
+
+4. **View Chat History:**
+   - All your queries and the corresponding AI responses are displayed in the chat history for your reference.
+""")
+
+                chatbot = gr.Chatbot(label="💬 Chat with SmartMarks", type='messages')
                 user_input = gr.Textbox(
                     label="✍️ Ask about your bookmarks",
                     placeholder="e.g., Do I have any bookmarks about AI?"
                 )
                 chat_button = gr.Button("📨 Send")
 
+                chat_button.click(
+                    chatbot_response,
+                    inputs=[user_input, chatbot],
+                    outputs=chatbot
+                )
+
             # Manage Bookmarks Tab
             with gr.Tab("Manage Bookmarks"):
                 gr.Markdown("""
-                ## 🛠️ **Manage Bookmarks**
-                Select bookmarks to delete or edit their categories.
-                """)
+## 🛠️ **Manage Bookmarks**
+
+### 🗂️ **Features:**
+
+1. **View Bookmarks:**
+   - All your processed bookmarks are displayed here with their respective categories and summaries.
+
+2. **Select Bookmarks:**
+   - Use the checkboxes next to each bookmark to select one, multiple, or all bookmarks you wish to manage.
+
+3. **Delete Selected Bookmarks:**
+   - After selecting the desired bookmarks, click the **"🗑️ Delete Selected"** button to remove them from your list.
+
+4. **Edit Categories:**
+   - Select the bookmarks you want to re-categorize.
+   - Choose a new category from the dropdown menu labeled **"🆕 New Category"**.
+   - Click the **"✏️ Edit Category"** button to update their categories.
+
+5. **Export Bookmarks:**
+   - Click the **"💾 Export"** button to download your updated bookmarks as an HTML file.
+   - This file can be uploaded back to your browser to reflect the changes made within SmartMarks.
+
+6. **Refresh Bookmarks:**
+   - Click the **"🔄 Refresh Bookmarks"** button to ensure the latest state is reflected in the display.
+""")
 
                 manage_output = gr.Textbox(label="🔄 Status", interactive=False)
                 bookmark_selector = gr.CheckboxGroup(
@@ -741,38 +846,38 @@ def build_app():
                     delete_button = gr.Button("🗑️ Delete Selected")
                     edit_category_button = gr.Button("✏️ Edit Category")
                     export_button = gr.Button("💾 Export")
+                    refresh_button = gr.Button("🔄 Refresh Bookmarks")
 
                 download_link = gr.File(label="📥 Download Exported Bookmarks")
 
-            # Set up event handlers
-            process_button.click(
-                process_uploaded_file,
-                inputs=upload,
-                outputs=[output_text, bookmark_display, bookmark_selector, bookmark_display_manage]
-            )
-
-            chat_button.click(
-                chatbot_response,
-                inputs=[user_input, chatbot],
-                outputs=chatbot
-            )
+                # Define button actions
+                delete_button.click(
+                    delete_selected_bookmarks,
+                    inputs=[bookmark_selector, state_bookmarks],
+                    outputs=[manage_output, bookmark_selector, bookmark_display_manage]
+                )
 
-            delete_button.click(
-                delete_selected_bookmarks,
-                inputs=bookmark_selector,
-                outputs=[manage_output, bookmark_selector, bookmark_display_manage]
-            )
+                edit_category_button.click(
+                    edit_selected_bookmarks_category,
+                    inputs=[bookmark_selector, new_category, state_bookmarks],
+                    outputs=[manage_output, bookmark_selector, bookmark_display_manage, state_bookmarks]
+                )
 
-            edit_category_button.click(
-                edit_selected_bookmarks_category,
-                inputs=[bookmark_selector, new_category],
-                outputs=[manage_output, bookmark_selector, bookmark_display_manage]
-            )
+                export_button.click(
+                    export_bookmarks,
+                    outputs=download_link
+                )
 
-            export_button.click(
-                export_bookmarks,
-                outputs=download_link
-            )
+                refresh_button.click(
+                    lambda state_bookmarks: (
+                        [
+                            f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(state_bookmarks)
+                        ],
+                        display_bookmarks()
+                    ),
+                    inputs=[state_bookmarks],
+                    outputs=[bookmark_selector, bookmark_display_manage]
+                )
 
         logger.info("Launching Gradio app")
         demo.launch(debug=True)