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,9 @@ console_handler.setFormatter(formatter)
 # Add the handler to the logger
 logger.addHandler(console_handler)
 
-# Initialize variables
-logger.info("Initializing variables")
+# Initialize models and variables
+logger.info("Initializing models and variables")
+embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
 faiss_index = None
 bookmarks = []
 fetch_cache = {}
@@ -80,21 +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)
-
-# Global variables for models to enable lazy loading
-embedding_model = None
-
-def get_embedding_model():
-    global embedding_model
-    if embedding_model is None:
-        logger.info("Loading SentenceTransformer model...")
-        embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
-        logger.info("SentenceTransformer model loaded.")
-    return embedding_model
+openai.api_base = "https://api.groq.com/openai/v1"
 
 def extract_main_content(soup):
     """
@@ -171,20 +154,21 @@ def generate_summary_and_assign_category(bookmark):
     """
     logger.info(f"Generating summary and assigning category for bookmark: {bookmark.get('url')}")
 
-    max_retries = 5
+    max_retries = 3
     retry_count = 0
-    base_wait = 1  # Initial wait time in seconds
 
     while retry_count < max_retries:
         try:
             html_content = bookmark.get('html_content', '')
 
-            # Parse 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)
 
-            # Prepare prompt
+            # Prepare content for the prompt
             content_parts = []
             if metadata['title']:
                 content_parts.append(f"Title: {metadata['title']}")
@@ -197,17 +181,18 @@ def generate_summary_and_assign_category(bookmark):
 
             content_text = '\n'.join(content_parts)
 
-            # Determine prompt type
+            # Detect insufficient or erroneous content
             error_keywords = ['Access Denied', 'Security Check', 'Cloudflare', 'captcha', 'unusual traffic']
             if not content_text or len(content_text.split()) < 50:
                 use_prior_knowledge = True
-                logger.info(f"Content for {bookmark.get('url')} is insufficient. Using prior knowledge.")
+                logger.info(f"Content for {bookmark.get('url')} is insufficient. Instructing LLM to use prior knowledge.")
             elif any(keyword.lower() in content_text.lower() for keyword in error_keywords):
                 use_prior_knowledge = True
-                logger.info(f"Content for {bookmark.get('url')} contains error messages. Using prior knowledge.")
+                logger.info(f"Content for {bookmark.get('url')} contains error messages. Instructing LLM to use prior knowledge.")
             else:
                 use_prior_knowledge = False
 
+            # Shortened prompts
             if use_prior_knowledge:
                 prompt = f"""
 You are a knowledgeable assistant with up-to-date information as of 2023.
@@ -236,34 +221,52 @@ Summary: [Your summary]
 Category: [One category]
 """
 
-            # Acquire semaphore before making API call
-            api_semaphore.acquire()
-            try:
-                # Call the LLM via Groq Cloud API with exponential backoff
-                response = openai.ChatCompletion.create(
-                    model='llama-3.1-70b-versatile',  # Ensure this is the correct model name
-                    messages=[
-                        {"role": "user", "content": prompt}
-                    ],
-                    max_tokens=150,
-                    temperature=0.5,
-                )
-            finally:
-                # Release semaphore after API call
-                api_semaphore.release()
-
+            # Estimate tokens
+            def estimate_tokens(text):
+                return len(text) / 4  # Approximate token estimation
+
+            prompt_tokens = estimate_tokens(prompt)
+            max_tokens = 150  # Reduced from 200
+            total_tokens = prompt_tokens + max_tokens
+
+            # Calculate required delay
+            tokens_per_minute = 60000  # Adjust based on your rate limit
+            tokens_per_second = tokens_per_minute / 60
+            required_delay = total_tokens / tokens_per_second
+            sleep_time = max(required_delay, 1)
+
+            # 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.")
 
-            # Parse response
+            # Parse the response
             summary_match = re.search(r"Summary:\s*(.*)", content)
             category_match = re.search(r"Category:\s*(.*)", content)
 
-            bookmark['summary'] = summary_match.group(1).strip() if summary_match else 'No summary available.'
-            bookmark['category'] = category_match.group(1).strip().strip('"') if category_match else 'Uncategorized'
+            if summary_match:
+                bookmark['summary'] = summary_match.group(1).strip()
+            else:
+                bookmark['summary'] = 'No summary available.'
+
+            if category_match:
+                category = category_match.group(1).strip().strip('"')
+                if category in CATEGORIES:
+                    bookmark['category'] = category
+                else:
+                    bookmark['category'] = 'Uncategorized'
+            else:
+                bookmark['category'] = 'Uncategorized'
 
-            # Additional validation (optional)
+            # Simple keyword-based validation (Optional)
             summary_lower = bookmark['summary'].lower()
             url_lower = bookmark['url'].lower()
             if 'social media' in summary_lower or 'twitter' in summary_lower or 'x.com' in url_lower:
@@ -272,27 +275,19 @@ Category: [One category]
                 bookmark['category'] = 'Reference and Knowledge Bases'
 
             logger.info("Successfully generated summary and assigned category")
-
-            # **Introduce Fixed Delay After API Call**
-            time.sleep(1)  # Wait for 1 second before the next API call
-
-            break  # Exit loop on success
+            time.sleep(sleep_time)
+            break  # Exit the retry loop upon success
 
         except openai.error.RateLimitError as e:
             retry_count += 1
-            wait_time = base_wait * (2 ** retry_count)  # Exponential backoff
-            logger.warning(f"Rate limit reached. Waiting for {wait_time} seconds before retrying... (Attempt {retry_count}/{max_retries})")
+            wait_time = int(e.headers.get("Retry-After", 5))
+            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)
             bookmark['summary'] = 'No summary available.'
             bookmark['category'] = 'Uncategorized'
-            break  # Exit loop on non-rate limit errors
-
-    if retry_count == max_retries:
-        logger.error(f"Failed to generate summary for {bookmark.get('url')} after {max_retries} attempts.")
-        bookmark['summary'] = 'No summary available.'
-        bookmark['category'] = 'Uncategorized'
+            break  # Exit the retry loop on other exceptions
 
 def parse_bookmarks(file_content):
     """
@@ -332,7 +327,7 @@ def fetch_url_info(bookmark):
             'User-Agent': 'Mozilla/5.0',
             'Accept-Language': 'en-US,en;q=0.9',
         }
-        response = requests.get(url, headers=headers, timeout=5, verify=True, allow_redirects=True)  # Set verify=True
+        response = requests.get(url, headers=headers, timeout=5, verify=False, allow_redirects=True)
         bookmark['etag'] = response.headers.get('ETag', 'N/A')
         bookmark['status_code'] = response.status_code
 
@@ -352,13 +347,6 @@ def fetch_url_info(bookmark):
             bookmark['description'] = ''
             logger.info(f"Fetched information for {url}")
 
-    except requests.exceptions.SSLError as e:
-        bookmark['dead_link'] = True
-        bookmark['etag'] = 'N/A'
-        bookmark['status_code'] = 'SSL Error'
-        bookmark['description'] = ''
-        bookmark['html_content'] = ''
-        logger.error(f"SSL error fetching URL info for {url}: {e}", exc_info=True)
     except requests.exceptions.Timeout:
         bookmark['dead_link'] = False  # Mark as 'Unknown' instead of 'Dead'
         bookmark['etag'] = 'N/A'
@@ -389,26 +377,17 @@ 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:
-        # Use .get('summary', '') to avoid KeyError
-        summaries = [bookmark.get('summary', '') for bookmark in bookmarks_list]
-        
-        # Check for any empty summaries and log them
-        for i, summary in enumerate(summaries):
-            if not summary:
-                logger.warning(f"Bookmark at index {i} is missing a summary.")
-                summaries[i] = 'No summary available.'
-
-        embeddings = get_embedding_model().encode(summaries).astype('float32')
+        summaries = [bookmark['summary'] for bookmark in bookmarks_list]
+        embeddings = embedding_model.encode(summaries)
         dimension = embeddings.shape[1]
-        if faiss_index is None:
-            faiss_index = faiss.IndexIDMap(faiss.IndexFlatL2(dimension))
+        index = faiss.IndexIDMap(faiss.IndexFlatL2(dimension))
         # Assign unique IDs to each bookmark
         ids = np.array([bookmark['id'] for bookmark in bookmarks_list], dtype=np.int64)
-        faiss_index.add_with_ids(embeddings, ids)
+        index.add_with_ids(np.array(embeddings).astype('float32'), ids)
         logger.info("FAISS index built successfully with IDs")
+        return index
     except Exception as e:
         logger.error(f"Error in vectorizing and indexing: {e}", exc_info=True)
         raise
@@ -462,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.
     """
@@ -471,39 +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  # Return the unchanged state
-        )
+        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}")
-        return (
-            "⚠️ Error decoding the file. Please ensure it's a valid HTML file.",
-            "",
-            state_bookmarks  # Return the unchanged state
-        )
+        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()
 
     try:
         bookmarks = parse_bookmarks(file_content)
     except Exception as e:
-        logger.error(f"Error parsing bookmarks: {e}")
-        return (
-            "⚠️ Error parsing the bookmarks HTML file.",
-            "",
-            state_bookmarks  # Return the unchanged state
-        )
+        logger.error(f"Error parsing bookmarks: {e}", exc_info=True)
+        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  # Return the unchanged state
-        )
+        return "No bookmarks found in the uploaded file.", '', gr.update(choices=[]), display_bookmarks()
 
     # Assign unique IDs to bookmarks
     for idx, bookmark in enumerate(bookmarks):
@@ -511,135 +474,94 @@ 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)
 
-    # Generate summaries and assign categories
-    logger.info("Generating summaries and assigning categories")
-    with ThreadPoolExecutor(max_workers=1) as executor:  # Adjusted max_workers to 1
+    # Process bookmarks concurrently with LLM calls
+    logger.info("Processing bookmarks with LLM concurrently")
+    with ThreadPoolExecutor(max_workers=5) as executor:
         executor.map(generate_summary_and_assign_category, bookmarks)
 
-    # Log bookmarks to verify 'summary' and 'category' presence
-    for idx, bookmark in enumerate(bookmarks):
-        if 'summary' not in bookmark or 'category' not in bookmark:
-            logger.error(f"Bookmark at index {idx} is missing 'summary' or 'category': {bookmark}")
-        else:
-            logger.debug(f"Bookmark {idx} processed with summary and category.")
-
     try:
-        vectorize_and_index(bookmarks)
+        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  # Return the unchanged state
-        )
+        return "Error building search index.", '', gr.update(choices=[]), display_bookmarks()
 
     message = f"✅ Successfully processed {len(bookmarks)} bookmarks."
     logger.info(message)
 
     # Generate displays and updates
     bookmark_html = display_bookmarks()
-    choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(bookmarks)]
+    choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})"
+               for i, bookmark in enumerate(bookmarks)]
 
-    return (
-        message,
-        bookmark_html,
-        bookmarks.copy()  # Return the updated state
-    )
+    return message, bookmark_html, gr.update(choices=choices), 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.
     """
     global bookmarks, faiss_index
     if not selected_indices:
-        return "⚠️ No bookmarks selected.", gr.update(choices=[]), bookmark_display_manage.update(value=display_bookmarks()), state_bookmarks
+        return "⚠️ No bookmarks selected.", gr.update(choices=[]), display_bookmarks()
 
     ids_to_delete = []
     indices_to_delete = []
     for s in selected_indices:
-        try:
-            idx = int(s.split('.')[0]) - 1
-            if 0 <= idx < len(state_bookmarks):
-                bookmark_id = state_bookmarks[idx]['id']
-                ids_to_delete.append(bookmark_id)
-                indices_to_delete.append(idx)
-                logger.info(f"Deleting bookmark at index {idx + 1}")
-        except ValueError:
-            logger.error(f"Invalid selection format: {s}")
+        idx = int(s.split('.')[0]) - 1
+        if 0 <= idx < len(bookmarks):
+            bookmark_id = bookmarks[idx]['id']
+            ids_to_delete.append(bookmark_id)
+            indices_to_delete.append(idx)
+            logger.info(f"Deleting bookmark at index {idx + 1}")
 
     # Remove vectors from FAISS index
     if faiss_index is not None and ids_to_delete:
         faiss_index.remove_ids(np.array(ids_to_delete, dtype=np.int64))
 
     # Remove bookmarks from the list (reverse order to avoid index shifting)
-    bookmarks = state_bookmarks.copy()
     for idx in sorted(indices_to_delete, reverse=True):
         bookmarks.pop(idx)
 
     message = "🗑️ Selected bookmarks deleted successfully."
     logger.info(message)
-    choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(bookmarks)]
+    choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})"
+               for i, bookmark in enumerate(bookmarks)]
 
-    return (
-        message,
-        gr.update(choices=choices, value=[]),
-        bookmark_display_manage.update(value=display_bookmarks()),
-        bookmarks.copy()  # Return the updated state
-    )
+    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=[]),
-            bookmark_display_manage.update(value=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=[]),
-            bookmark_display_manage.update(value=display_bookmarks()),
-            state_bookmarks
-        )
+        return "⚠️ No new category selected.", gr.update(choices=[]), display_bookmarks()
 
-    bookmarks = state_bookmarks.copy()
-    for s in selected_indices:
-        try:
-            idx = int(s.split('.')[0]) - 1
-            if 0 <= idx < len(bookmarks):
-                bookmarks[idx]['category'] = new_category
-                logger.info(f"Updated category for bookmark {idx + 1} to {new_category}")
-        except ValueError:
-            logger.error(f"Invalid selection format: {s}")
+    indices = [int(s.split('.')[0])-1 for s in selected_indices]
+    for idx in indices:
+        if 0 <= idx < len(bookmarks):
+            bookmarks[idx]['category'] = new_category
+            logger.info(f"Updated category for bookmark {idx + 1} to {new_category}")
 
     message = "✏️ Category updated for selected bookmarks."
     logger.info(message)
 
     # Update choices and display
-    choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(bookmarks)]
+    choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})"
+               for i, bookmark in enumerate(bookmarks)]
 
-    return (
-        message,
-        gr.update(choices=choices, value=[]),
-        bookmark_display_manage.update(value=display_bookmarks()),
-        bookmarks.copy()  # Return the updated state
-    )
+    return message, gr.update(choices=choices), display_bookmarks()
 
-def export_bookmarks(state_bookmarks):
+def export_bookmarks():
     """
     Export bookmarks to an HTML file.
     """
-    bookmarks = state_bookmarks
     if not bookmarks:
         logger.warning("No bookmarks to export")
-        return "⚠️ No bookmarks to export."
+        return None  # Return None instead of a message
 
     try:
         logger.info("Exporting bookmarks to HTML")
@@ -653,36 +575,30 @@ def export_bookmarks(state_bookmarks):
             dl.append(dt)
         soup.append(dl)
         html_content = str(soup)
-        # Encode the HTML content to base64 for download
-        b64 = base64.b64encode(html_content.encode()).decode()
-        href = f'data:text/html;base64,{b64}'
+        # Save to a temporary file
+        output_file = "exported_bookmarks.html"
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write(html_content)
         logger.info("Bookmarks exported successfully")
-        return f'<a href="{href}" download="exported_bookmarks.html">💾 Download Exported Bookmarks</a>'
+        return output_file  # Return the file path
     except Exception as e:
-        logger.error(f"Error exporting bookmarks: {e}")
-        return "⚠️ Error exporting bookmarks."
+        logger.error(f"Error exporting bookmarks: {e}", exc_info=True)
+        return None  # Return None in case of error
 
-def chatbot_response(user_query, chat_history, state_bookmarks):
+def chatbot_response(user_query, chat_history):
     """
     Generate chatbot response using the FAISS index and embeddings, maintaining chat history.
     """
-    if not GROQ_API_KEY:
-        logger.warning("GROQ_API_KEY not set.")
-        return chat_history + [{"role": "system", "content": "⚠️ API key not set. Please set the GROQ_API_KEY environment variable in the Hugging Face Space settings."}]
-
-    bookmarks = state_bookmarks
-    if not bookmarks:
+    if not bookmarks or faiss_index is None:
         logger.warning("No bookmarks available for chatbot")
-        return chat_history + [{"role": "system", "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}")
 
     try:
-        # Ensure embedding model is loaded
-        model = get_embedding_model()
-
         # Encode the user query
-        query_vector = model.encode([user_query]).astype('float32')
+        query_vector = embedding_model.encode([user_query]).astype('float32')
 
         # Search the FAISS index
         k = 5  # Number of results to return
@@ -694,75 +610,65 @@ def chatbot_response(user_query, chat_history, state_bookmarks):
         matching_bookmarks = [id_to_bookmark.get(id) for id in ids if id in id_to_bookmark]
 
         if not matching_bookmarks:
-            response_text = "No relevant bookmarks found for your query."
-            logger.info(response_text)
-            return chat_history + [{"role": "assistant", "content": response_text}]
+            answer = "No relevant bookmarks found for your query."
+            chat_history.append((user_query, answer))
+            return chat_history
 
         # Format the response
-        bookmarks_info = "\n\n".join([
-            f"**Title:** {bookmark['title']}\n**URL:** {bookmark['url']}\n**Summary:** {bookmark['summary']}"
+        bookmarks_info = "\n".join([
+            f"Title: {bookmark['title']}\nURL: {bookmark['url']}\nSummary: {bookmark['summary']}"
             for bookmark in matching_bookmarks
         ])
 
-        # Construct the prompt
+        # Use the LLM via Groq Cloud API to generate a response
         prompt = f"""
 A user asked: "{user_query}"
 Based on the bookmarks below, provide a helpful answer to the user's query, referencing the relevant bookmarks.
-
 Bookmarks:
 {bookmarks_info}
-
 Provide a concise and helpful response.
 """
 
-        # Acquire semaphore before making API call
-        api_semaphore.acquire()
-        try:
-            # Call the LLM via Groq Cloud API with exponential backoff
-            max_retries = 5
-            retry_count = 0
-            base_wait = 1  # Initial wait time in seconds
-
-            while retry_count < max_retries:
-                try:
-                    response = openai.ChatCompletion.create(
-                        model='llama-3.1-70b-versatile',  # Ensure this is the correct model name
-                        messages=[
-                            {"role": "user", "content": prompt}
-                        ],
-                        max_tokens=300,
-                        temperature=0.7,
-                    )
-                    answer = response['choices'][0]['message']['content'].strip()
-                    logger.info("Chatbot response generated")
-
-                    # **Introduce Fixed Delay After API Call**
-                    time.sleep(1)  # Wait for 1 second before the next API call
-
-                    return chat_history + [{"role": "user", "content": user_query}, {"role": "assistant", "content": answer}]
-                except openai.error.RateLimitError as e:
-                    retry_count += 1
-                    wait_time = base_wait * (2 ** retry_count)  # Exponential backoff
-                    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:
-                    error_message = f"⚠️ Error processing your query: {str(e)}"
-                    logger.error(error_message, exc_info=True)
-                    return chat_history + [{"role": "assistant", "content": error_message}]
-
-            # If max retries reached
-            error_message = "⚠️ Unable to process your query at the moment. Please try again later."
-            logger.error(error_message)
-            return chat_history + [{"role": "assistant", "content": error_message}]
-
-        finally:
-            # Release semaphore after API call
-            api_semaphore.release()
-
+        # Estimate tokens
+        def estimate_tokens(text):
+            return len(text) / 4  # Approximate token estimation
+
+        prompt_tokens = estimate_tokens(prompt)
+        max_tokens = 300  # Adjust as needed
+        total_tokens = prompt_tokens + max_tokens
+
+        # Calculate required delay
+        tokens_per_minute = 60000  # Adjust based on your rate limit
+        tokens_per_second = tokens_per_minute / 60
+        required_delay = total_tokens / tokens_per_second
+        sleep_time = max(required_delay, 1)
+
+        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((user_query, answer))
+        return chat_history
+
+    except openai.error.RateLimitError as e:
+        wait_time = int(e.headers.get("Retry-After", 5))
+        logger.warning(f"Rate limit reached. Waiting for {wait_time} seconds before retrying...")
+        time.sleep(wait_time)
+        return chatbot_response(user_query, chat_history)  # Retry after waiting
     except Exception as e:
         error_message = f"⚠️ Error processing your query: {str(e)}"
         logger.error(error_message, exc_info=True)
-        return chat_history + [{"role": "assistant", "content": error_message}]
+        chat_history.append((user_query, error_message))
+        return chat_history
 
 def build_app():
     """
@@ -770,186 +676,109 @@ def build_app():
     """
     try:
         logger.info("Building Gradio app")
-        with gr.Blocks(css="app.css") as demo:  # Load external CSS file
-            # Shared states
-            state_bookmarks = gr.State([])
-            chat_history = gr.State([])
-
+        with gr.Blocks(css="app.css") as demo:
             # 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. Whether you're looking to categorize your links, retrieve information quickly, or maintain an updated list, SmartMarks has you covered.
-
----
-
-## 🚀 **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]
-                )
-
             # Chat with Bookmarks Tab
             with gr.Tab("Chat with Bookmarks"):
                 gr.Markdown("""
-## 💬 **Chat with Bookmarks**
-
-### 🤖 **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.
-""")
-
-                with gr.Row():
-                    chat_history_display = gr.Chatbot(label="🗨️ Chat History", type="messages")
-                    with gr.Column(scale=1):
-                        chat_input = gr.Textbox(
-                            label="✍️ Ask about your bookmarks",
-                            placeholder="e.g., Do I have any bookmarks about GenerativeAI?",
-                            lines=1,
-                            interactive=True
-                        )
-                        chat_button = gr.Button("📨 Send")
-
-                # When user presses Enter in chat_input
-                chat_input.submit(
-                    chatbot_response,
-                    inputs=[chat_input, chat_history_display, state_bookmarks],
-                    outputs=chat_history_display
-                )
-
-                # When user clicks Send button
-                chat_button.click(
-                    chatbot_response,
-                    inputs=[chat_input, chat_history_display, state_bookmarks],
-                    outputs=chat_history_display
+                ## 💬 **Chat with Bookmarks**
+                Ask questions about your bookmarks and get relevant results.
+                """)
+
+                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")
 
             # 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(
                     label="✅ Select Bookmarks",
-                    choices=[],
-                    value=[]
+                    choices=[]
+                )
+                new_category = gr.Dropdown(
+                    label="🆕 New Category",
+                    choices=CATEGORIES,
+                    value="Uncategorized"
                 )
-                new_category_input = gr.Dropdown(label="🆕 New Category", choices=CATEGORIES, value="Uncategorized")
                 bookmark_display_manage = gr.HTML(label="📄 Bookmarks")
 
                 with gr.Row():
                     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.HTML(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, state_bookmarks]
-                )
 
-                edit_category_button.click(
-                    edit_selected_bookmarks_category,
-                    inputs=[bookmark_selector, new_category_input, state_bookmarks],
-                    outputs=[manage_output, bookmark_selector, bookmark_display_manage, state_bookmarks]
-                )
-
-                export_button.click(
-                    export_bookmarks,
-                    inputs=[state_bookmarks],
-                    outputs=download_link
-                )
-
-                refresh_button.click(
-                    lambda bookmarks: (
-                        [
-                            f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(bookmarks)
-                        ],
-                        display_bookmarks()
-                    ),
-                    inputs=[state_bookmarks],
-                    outputs=[bookmark_selector, bookmark_display_manage]
-                )
+                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
+            )
+
+            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],
+                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)
     except Exception as e:
-        logger.error(f"Error building Gradio app: {e}", exc_info=True)
-        print(f"Error building Gradio app: {e}")
+        logger.error(f"Error building the app: {e}", exc_info=True)
+        print(f"Error building the app: {e}")
 
 if __name__ == "__main__":
     build_app()