Update app.py

app.py

@@ -15,9 +15,6 @@ from concurrent.futures import ThreadPoolExecutor
 import threading
 from html import escape
 
-# Import OpenAI library
-import openai
-
 # Suppress specific warnings
 import urllib3
 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
@@ -73,19 +70,35 @@ CATEGORIES = [
     "Uncategorized",
 ]
 
-# Set up OpenAI API key and base URL
-OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
+# Remove OpenAI dependencies
+# Define a function to generate responses using llama-3.1-70b-versatile
+def generate_llama_response(prompt):
+    """
+    Generate a response using the llama-3.1-70b-versatile model.
 
-if not OPENAI_API_KEY:
-    logger.error("OPENAI_API_KEY environment variable not set.")
+    Replace the implementation below with the actual method to interact with your LLM.
+    This could be an API call to a local server, a cloud service, or any interface you have set up.
 
-openai.api_key = OPENAI_API_KEY
-# If you're using a custom API base, uncomment and set it
-# openai.api_base = "https://api.your-provider.com/v1"
+    Example (pseudo-code):
+    response = requests.post("http://localhost:5000/generate", json={"prompt": prompt})
+    return response.json().get("response", "")
 
-# Initialize global variables for rate limiting
-api_lock = threading.Lock()
-last_api_call_time = 0
+    For demonstration purposes, we'll return a placeholder response.
+    """
+    try:
+        # Example implementation; replace with actual API call or method
+        # For instance, if using a local API:
+        # response = requests.post("http://localhost:5000/generate", json={"prompt": prompt})
+        # return response.json().get("response", "")
+        
+        # Placeholder response
+        logger.info("Generating response using llama-3.1-70b-versatile")
+        # Simulate processing time
+        time.sleep(1)
+        return "This is a placeholder response from llama-3.1-70b-versatile."
+    except Exception as e:
+        logger.error(f"Error generating response from llama: {e}", exc_info=True)
+        return "Error generating response."
 
 def extract_main_content(soup):
     """
@@ -158,7 +171,7 @@ def get_page_metadata(soup):
 
 def generate_summary_and_assign_category(bookmark):
     """
-    Generate a concise summary and assign a category using a single LLM call.
+    Generate a concise summary and assign a category using the llama-3.1-70b-versatile model.
     """
     logger.info(f"Generating summary and assigning category for bookmark: {bookmark.get('url')}")
 
@@ -167,8 +180,8 @@ def generate_summary_and_assign_category(bookmark):
 
     while retry_count < max_retries:
         try:
-            # Rate Limiting Logic
-            with api_lock:
+            # Rate Limiting Logic (if necessary)
+            with lock:
                 global last_api_call_time
                 current_time = time.time()
                 elapsed = current_time - last_api_call_time
@@ -237,23 +250,15 @@ Summary: [Your summary]
 Category: [One category]
 """
 
-            # Call the LLM via OpenAI API
-            response = openai.ChatCompletion.create(
-                model='gpt-4',  # Ensure you're using a valid and accessible model
-                messages=[
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=150,
-                temperature=0.5,
-            )
+            # Generate response using llama-3.1-70b-versatile
+            response = generate_llama_response(prompt)
 
-            content = response['choices'][0]['message']['content'].strip()
-            if not content:
+            if not response:
                 raise ValueError("Empty response received from the model.")
 
             # Parse the response
-            summary_match = re.search(r"Summary:\s*(.*)", content)
-            category_match = re.search(r"Category:\s*(.*)", content)
+            summary_match = re.search(r"Summary:\s*(.*)", response)
+            category_match = re.search(r"Category:\s*(.*)", response)
 
             if summary_match:
                 bookmark['summary'] = summary_match.group(1).strip()
@@ -280,16 +285,11 @@ Category: [One category]
             logger.info("Successfully generated summary and assigned category")
             break  # Exit the retry loop upon success
 
-        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})")
-            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 the retry loop on other exceptions
+            break  # Exit the retry loop on exceptions
 
 def parse_bookmarks(file_content):
     """
@@ -624,8 +624,8 @@ def chatbot_response(user_query, chat_history):
         # Append user's message to chat history
         chat_history.append({"role": "user", "content": user_query})
 
-        # Rate Limiting Logic
-        with api_lock:
+        # Rate Limiting Logic (if necessary)
+        with lock:
             global last_api_call_time
             current_time = time.time()
             elapsed = current_time - last_api_call_time
@@ -665,28 +665,19 @@ Bookmarks:
 Provide a concise and helpful response.
 """
 
-        # Call the LLM via OpenAI API
-        response = openai.ChatCompletion.create(
-            model='gpt-4',  # Ensure you're using a valid and accessible model
-            messages=[
-                {"role": "user", "content": prompt}
-            ],
-            max_tokens=300,
-            temperature=0.7,
-        )
-
-        answer = response['choices'][0]['message']['content'].strip()
+        # Generate response using llama-3.1-70b-versatile
+        response = generate_llama_response(prompt)
+
+        if not response:
+            raise ValueError("Empty response received from the model.")
+
+        answer = response.strip()
         logger.info("Chatbot response generated")
 
         # Append the assistant's response to chat history
         chat_history.append({"role": "assistant", "content": 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)