Update app.py

app.py

@@ -19,10 +19,6 @@ 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)
@@ -38,8 +34,8 @@ console_handler.setFormatter(formatter)
 # Add the handler to the logger
 logger.addHandler(console_handler)
 
-# Initialize variables and models
-logger.info("Initializing variables and models")
+# Initialize models and variables
+logger.info("Initializing models and variables")
 embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
 faiss_index = None
 bookmarks = []
@@ -81,10 +77,7 @@ 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"  # Ensure this is the correct base URL
-
-# Initialize semaphore for rate limiting (allowing 1 concurrent API call)
-api_semaphore = threading.Semaphore(1)
+openai.api_base = "https://api.groq.com/openai/v1"
 
 def extract_main_content(soup):
     """
@@ -233,7 +226,7 @@ Category: [One category]
                 return len(text) / 4  # Approximate token estimation
 
             prompt_tokens = estimate_tokens(prompt)
-            max_tokens = 150  # Adjusted from 200
+            max_tokens = 150  # Reduced from 200
             total_tokens = prompt_tokens + max_tokens
 
             # Calculate required delay
@@ -242,22 +235,15 @@ Category: [One category]
             required_delay = total_tokens / tokens_per_second
             sleep_time = max(required_delay, 1)
 
-            # Acquire semaphore before making API call
-            api_semaphore.acquire()
-            try:
-                # Call the LLM via Groq Cloud API
-                response = openai.ChatCompletion.create(
-                    model='llama-3.1-70b-versatile',  # Using the specified model
-                    messages=[
-                        {"role": "user", "content": prompt}
-                    ],
-                    max_tokens=int(max_tokens),
-                    temperature=0.5,
-                )
-            finally:
-                # Release semaphore after API call
-                api_semaphore.release()
-
+            # Call the LLM via Groq Cloud API
+            response = openai.ChatCompletion.create(
+                model='llama-3.1-70b-versatile',  # Using the specified model
+                messages=[
+                    {"role": "user", "content": prompt}
+                ],
+                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.")
@@ -295,7 +281,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... (Attempt {retry_count}/{max_retries})")
+            logger.warning(f"Rate limit reached. Waiting for {wait_time} seconds before retrying...")
             time.sleep(wait_time)
         except Exception as e:
             logger.error(f"Error generating summary and assigning category: {e}", exc_info=True)
@@ -391,7 +377,6 @@ 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]
@@ -401,7 +386,6 @@ 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:
@@ -457,7 +441,7 @@ def display_bookmarks():
     logger.info("HTML display generated")
     return cards
 
-def process_uploaded_file(file, state_bookmarks):
+def process_uploaded_file(file):
     """
     Process the uploaded bookmarks file.
     """
@@ -466,23 +450,23 @@ def process_uploaded_file(file, state_bookmarks):
 
     if file is None:
         logger.warning("No file uploaded")
-        return "Please upload a bookmarks HTML file.", '', state_bookmarks, display_bookmarks()
+        return "Please upload a bookmarks HTML file.", '', gr.update(choices=[]), 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.", '', state_bookmarks, display_bookmarks()
+        return "Error decoding the file. Please ensure it's a valid HTML file.", '', gr.update(choices=[]), 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.", '', state_bookmarks, display_bookmarks()
+        return "Error parsing the bookmarks HTML file.", '', gr.update(choices=[]), display_bookmarks()
 
     if not bookmarks:
         logger.warning("No bookmarks found in the uploaded file")
-        return "No bookmarks found in the uploaded file.", '', state_bookmarks, display_bookmarks()
+        return "No bookmarks found in the uploaded file.", '', gr.update(choices=[]), display_bookmarks()
 
     # Assign unique IDs to bookmarks
     for idx, bookmark in enumerate(bookmarks):
@@ -490,19 +474,19 @@ def process_uploaded_file(file, state_bookmarks):
 
     # Fetch bookmark info concurrently
     logger.info("Fetching URL info concurrently")
-    with ThreadPoolExecutor(max_workers=3) as executor:  # Adjusted max_workers to 3
+    with ThreadPoolExecutor(max_workers=20) as executor:
         executor.map(fetch_url_info, bookmarks)
 
     # Process bookmarks concurrently with LLM calls
     logger.info("Processing bookmarks with LLM concurrently")
-    with ThreadPoolExecutor(max_workers=1) as executor:  # Adjusted max_workers to 1
+    with ThreadPoolExecutor(max_workers=5) as executor:
         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.", '', state_bookmarks, display_bookmarks()
+        return "Error building search index.", '', gr.update(choices=[]), display_bookmarks()
 
     message = f"✅ Successfully processed {len(bookmarks)} bookmarks."
     logger.info(message)
@@ -512,12 +496,9 @@ def process_uploaded_file(file, state_bookmarks):
     choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})"
                for i, bookmark in enumerate(bookmarks)]
 
-    # Update state
-    state_bookmarks = bookmarks.copy()
+    return message, bookmark_html, gr.update(choices=choices), bookmark_html
 
-    return message, bookmark_html, state_bookmarks, bookmark_html
-
-def delete_selected_bookmarks(selected_indices, state_bookmarks):
+def delete_selected_bookmarks(selected_indices):
     """
     Delete selected bookmarks and remove their vectors from the FAISS index.
     """
@@ -548,19 +529,16 @@ def delete_selected_bookmarks(selected_indices, state_bookmarks):
     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, state_bookmarks):
+def edit_selected_bookmarks_category(selected_indices, new_category):
     """
     Edit category of selected bookmarks.
     """
     if not selected_indices:
-        return "⚠️ No bookmarks selected.", gr.update(choices=[]), display_bookmarks(), state_bookmarks
+        return "⚠️ No bookmarks selected.", gr.update(choices=[]), display_bookmarks()
     if not new_category:
-        return "⚠️ No new category selected.", gr.update(choices=[]), display_bookmarks(), state_bookmarks
+        return "⚠️ No new category selected.", gr.update(choices=[]), display_bookmarks()
 
     indices = [int(s.split('.')[0])-1 for s in selected_indices]
     for idx in indices:
@@ -575,10 +553,7 @@ def edit_selected_bookmarks_category(selected_indices, new_category, state_bookm
     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(), state_bookmarks
+    return message, gr.update(choices=choices), display_bookmarks()
 
 def export_bookmarks():
     """
@@ -616,7 +591,7 @@ 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({"role": "assistant", "content": "⚠️ No bookmarks available. Please upload and process your bookmarks first."})
+        chat_history.append((user_query, "⚠️ No bookmarks available. Please upload and process your bookmarks first."))
         return chat_history
 
     logger.info(f"Chatbot received query: {user_query}")
@@ -636,7 +611,7 @@ def chatbot_response(user_query, chat_history):
 
         if not matching_bookmarks:
             answer = "No relevant bookmarks found for your query."
-            chat_history.append({"role": "assistant", "content": answer})
+            chat_history.append((user_query, answer))
             return chat_history
 
         # Format the response
@@ -668,28 +643,20 @@ Provide a concise and helpful response.
         required_delay = total_tokens / tokens_per_second
         sleep_time = max(required_delay, 1)
 
-        # Acquire semaphore before making API call
-        api_semaphore.acquire()
-        try:
-            # Call the LLM via Groq Cloud API
-            response = openai.ChatCompletion.create(
-                model='llama-3.1-70b-versatile',  # Using the specified model
-                messages=[
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=int(max_tokens),
-                temperature=0.7,
-            )
-        finally:
-            # Release semaphore after API call
-            api_semaphore.release()
-
+        response = openai.ChatCompletion.create(
+            model='llama-3.1-70b-versatile',  # Using the specified model
+            messages=[
+                {"role": "user", "content": prompt}
+            ],
+            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({"role": "assistant", "content": answer})
+        chat_history.append((user_query, answer))
         return chat_history
 
     except openai.error.RateLimitError as e:
@@ -700,7 +667,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({"role": "assistant", "content": error_message})
+        chat_history.append((user_query, error_message))
         return chat_history
 
 def build_app():
@@ -710,119 +677,53 @@ 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.
-
-Navigate through the tabs to explore each feature in detail.
-""")
+            # 📚 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.
+            """)
 
             # Upload and Process Bookmarks Tab
             with gr.Tab("Upload and Process Bookmarks"):
                 gr.Markdown("""
-## 📂 **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 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 = 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**
+                ## 💬 **Chat with Bookmarks**
+                Ask questions about your bookmarks and get relevant results.
+                """)
 
-### 🤖 **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')
+                chatbot = gr.Chatbot(label="💬 Chat with SmartMarks")
                 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**
-
-### 🗂️ **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 Bookmarks**
+                Select bookmarks to delete or edit their categories.
+                """)
 
                 manage_output = gr.Textbox(label="🔄 Status", interactive=False)
                 bookmark_selector = gr.CheckboxGroup(
@@ -840,38 +741,38 @@ Navigate through the tabs to explore each feature in detail.
                     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")
 
-                # Define button actions
-                delete_button.click(
-                    delete_selected_bookmarks,
-                    inputs=[bookmark_selector, state_bookmarks],
-                    outputs=[manage_output, bookmark_selector, bookmark_display_manage]
-                )
+            # Set up event handlers
+            process_button.click(
+                process_uploaded_file,
+                inputs=upload,
+                outputs=[output_text, bookmark_display, 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]
-                )
+            chat_button.click(
+                chatbot_response,
+                inputs=[user_input, chatbot],
+                outputs=chatbot
+            )
 
-                export_button.click(
-                    export_bookmarks,
-                    outputs=download_link
-                )
+            delete_button.click(
+                delete_selected_bookmarks,
+                inputs=bookmark_selector,
+                outputs=[manage_output, bookmark_selector, bookmark_display_manage]
+            )
 
-                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]
-                )
+            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
+            )
 
         logger.info("Launching Gradio app")
         demo.launch(debug=True)