Update app.py

app.py

@@ -3,35 +3,46 @@ from openai import OpenAI
 import requests
 import json
 import os
-from typing import Dict, List
 import logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-OPENAI_API_KEY = os.getenv('openaikey')
-RAINDROP_TOKEN = os.getenv('raindroptoken')
+from typing import Dict, List
+from datetime import datetime
 
-if not OPENAI_API_KEY or not RAINDROP_TOKEN:
-    raise EnvironmentError(
-        "Missing required environment variables. Please ensure 'openaikey' and 'raindroptoken' are set."
-    )
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
 
 class RaindropSearchBot:
     def __init__(self):
-        self.openai_api_key = OPENAI_API_KEY
-        self.raindrop_api_token = RAINDROP_TOKEN
+        self.openai_api_key = os.getenv('openaikey')
+        self.raindrop_api_token = os.getenv('raindroptoken')
+        if not self.openai_api_key or not self.raindrop_api_token:
+            raise EnvironmentError(
+                "Missing required environment variables. Please ensure 'openaikey' and 'raindroptoken' are set."
+            )
         self.client = OpenAI(api_key=self.openai_api_key)
-        
+
     def generate_search_query(self, user_request: str) -> str:
-        """Convert user request to a tailored search query using OpenAI."""
-        prompt = """
-        Create a search query for Raindrop.io bookmarks about this topic.
-        Use simple keywords and phrases. Don't use quotes or complex operators.
-        Only return the search terms themselves.
+        """Convert user request to optimized search terms."""
+        logger.info(f"Generating search query for: {user_request}")
         
-        Topic: {}
-        """.format(user_request)
+        prompt = f"""
+        You are a search expert. Create a search query to find relevant documents about:
+        {user_request}
         
+        Guidelines:
+        - Focus on key concepts and synonyms
+        - Use simple keywords that would appear in titles or descriptions
+        - Avoid complex operators or special characters
+        - Return only the search terms, no explanation
+        - Include alternative phrasings
+        - Keep it concise (max 3-4 key terms/phrases)
+        
+        Return only the search query terms.
+        """
+
         try:
             response = self.client.chat.completions.create(
                 model="gpt-4o-mini",
@@ -39,129 +50,132 @@ class RaindropSearchBot:
                 temperature=0.3,
                 max_tokens=50
             )
-            query = response.choices[0].message.content.strip()
-            logger.info(f"Generated query: {query}")
-            return query
+            search_query = response.choices[0].message.content.strip()
+            logger.info(f"Generated search query: {search_query}")
+            return search_query
         except Exception as e:
-            logger.error(f"Error generating query: {e}")
+            logger.error(f"Error generating search query: {e}")
             return user_request
 
     def search_raindrop(self, search_query: str) -> List[Dict]:
-        """Search Raindrop.io with the generated query."""
+        """Search Raindrop.io with enhanced error handling and logging."""
+        logger.info(f"Searching Raindrop with query: {search_query}")
+
         headers = {
             "Authorization": f"Bearer {self.raindrop_api_token}"
         }
         
-        # First get all collections
-        collections_response = requests.get(
-            "https://api.raindrop.io/rest/v1/collections",
-            headers=headers
-        )
-        
-        if collections_response.status_code != 200:
-            logger.error(f"Failed to get collections: {collections_response.text}")
+        # Test API connection first
+        try:
+            test_response = requests.get(
+                "https://api.raindrop.io/rest/v1/user",
+                headers=headers
+            )
+            if test_response.status_code != 200:
+                logger.error(f"API test failed: {test_response.status_code}")
+                return []
+        except Exception as e:
+            logger.error(f"API connection error: {e}")
             return []
-            
-        # Search parameters
-        params = {
-            "search": search_query,
-            "perpage": 50,  # Increased from 10
-            "sort": "-created",
-            "page": 0
-        }
-        
+
+        # Perform search
         try:
+            params = {
+                "search": search_query,
+                "perpage": 50,
+                "sort": "-created",
+                "page": 0
+            }
+            
             response = requests.get(
-                "https://api.raindrop.io/rest/v1/raindrops/0",  # 0 means search all collections
+                "https://api.raindrop.io/rest/v1/raindrops/0",
                 headers=headers,
                 params=params
             )
             
-            logger.info(f"Search API response status: {response.status_code}")
-            
             if response.status_code == 200:
                 data = response.json()
                 items = data.get("items", [])
                 logger.info(f"Found {len(items)} results")
                 return items
             else:
-                logger.error(f"Search failed: {response.text}")
+                logger.error(f"Search failed: {response.status_code}")
                 return []
-                
         except Exception as e:
-            logger.error(f"Error during search: {e}")
+            logger.error(f"Search error: {e}")
             return []
 
-    def format_results(self, results: List[Dict]) -> str:
-        """Format the search results and generate an AI response."""
+    def analyze_results(self, results: List[Dict], user_query: str) -> str:
+        """Generate an analysis of the search results."""
         if not results:
-            return "No results found. Try modifying your search terms."
-        
-        # Filter out broken links and empty content
-        valid_results = [
-            item for item in results 
-            if item.get('link') and (item.get('excerpt') or item.get('description'))
-        ]
-        
-        if not valid_results:
-            return "Found results but no readable content to analyze. Try different search terms."
+            return "No relevant results found. Try modifying your search terms."
 
-        # Create context for AI response
-        context = "Based on these sources:\n\n"
-        for item in valid_results:
-            context += f"Title: {item.get('title', 'No Title')}\n"
-            context += f"Content: {item.get('excerpt') or item.get('description', 'No content')}\n\n"
+        # Create context for analysis
+        context = f"Based on the search query: '{user_query}'\n\n"
+        context += "Analyze these relevant sources:\n\n"
+        
+        for item in results:
+            context += f"Title: {item.get('title', 'No title')}\n"
+            if item.get('excerpt'):
+                context += f"Content: {item['excerpt'][:500]}...\n"
+            context += f"Created: {item.get('created', 'No date')}\n\n"
 
-        # Generate AI response
         try:
             prompt = f"""
-            Based on the provided sources, create a comprehensive response about the topic.
-            Synthesize the information and present key insights.
-            Keep the response concise and informative.
+            Based on these search results, provide a comprehensive analysis of {user_query}.
+            
+            Requirements:
+            1. Focus only on information directly related to the query
+            2. Organize the response by key themes or chronologically
+            3. Include only factual information from the sources
+            4. Highlight any significant developments or changes
+            5. Note any gaps in information
             
-            Sources:
+            Context:
             {context}
             """
-            
+
             response = self.client.chat.completions.create(
                 model="gpt-4o-mini",
                 messages=[{"role": "user", "content": prompt}],
-                temperature=0.7,
-                max_tokens=500
+                temperature=0.5,
+                max_tokens=1000
             )
-            ai_response = response.choices[0].message.content
+            
+            analysis = response.choices[0].message.content
+            return analysis
         except Exception as e:
-            logger.error(f"Error generating AI response: {e}")
-            ai_response = "Unable to generate summary from the search results."
+            logger.error(f"Analysis generation error: {e}")
+            return "Error generating analysis."
 
-        # Format the final output
-        formatted_output = f"{ai_response}\n\n"
-        formatted_output += "-------\n\n"
-        formatted_output += "🔍 Source Links:\n\n"
-        
-        for idx, item in enumerate(valid_results, 1):
-            # Title and link
-            formatted_output += f"{idx}. {item.get('title', 'No Title')}\n"
-            formatted_output += f"   Link: {item.get('link', 'No Link')}\n"
-            
-            # Tags
-            if item.get('tags'):
-                formatted_output += f"   Tags: {', '.join(item['tags'])}\n"
-                
-            # Description/excerpt if available
-            if item.get('excerpt'):
-                formatted_output += f"   Description: {item['excerpt'][:200]}...\n"
-                
-            # Created date
-            if item.get('created'):
-                formatted_output += f"   Created: {item['created'][:10]}\n"
-                
-            formatted_output += "\n"
-            
-        return formatted_output
+    def format_results(self, results: List[Dict], analysis: str) -> str:
+        """Format the search results with analysis."""
+        if not results:
+            return "No results found. Try modifying your search terms."
+
+        output = f"{analysis}\n\n"
+        output += "-------\n\n"
+        output += "🔍 Source Links:\n\n"
+
+        for idx, item in enumerate(results, 1):
+            # Only include if there's at least a title or link
+            if item.get('title') or item.get('link'):
+                output += f"{idx}. {item.get('title', 'No Title')}\n"
+                if item.get('link'):
+                    output += f"   Link: {item['link']}\n"
+                if item.get('tags'):
+                    output += f"   Tags: {', '.join(item['tags'])}\n"
+                if item.get('excerpt'):
+                    output += f"   Description: {item['excerpt'][:200]}...\n"
+                if item.get('created'):
+                    created_date = item['created'][:10]  # Get just the date part
+                    output += f"   Created: {created_date}\n"
+                output += "\n"
+
+        return output
 
     def process_request(self, user_request: str) -> str:
-        """Process the user request and return formatted results with AI response."""
+        """Process the user request with enhanced error handling."""
         try:
             logger.info(f"Processing request: {user_request}")
             
@@ -173,31 +187,34 @@ class RaindropSearchBot:
             results = self.search_raindrop(search_query)
             logger.info(f"Found {len(results)} results")
             
-            # Format results and generate AI response
-            return self.format_results(results)
+            # Generate analysis
+            analysis = self.analyze_results(results, user_request)
+            
+            # Format and return results
+            return self.format_results(results, analysis)
             
         except Exception as e:
             logger.error(f"Error processing request: {e}", exc_info=True)
-            return f"An error occurred: {str(e)}"
+            return f"An error occurred while processing your request. Please try again."
 
-# Initialize the bot
+# Initialize bot
 bot = RaindropSearchBot()
 
 # Create Gradio interface
 def chatbot_interface(user_input: str) -> str:
     return bot.process_request(user_input)
 
-# Define and launch the Gradio interface
-with gr.Blocks(title="Raindrop.io Link Search Assistant", theme=gr.themes.Soft()) as demo:
+# Define and launch the interface
+with gr.Blocks(title="Raindrop.io Search Assistant", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # 🔍 Raindrop.io Link Search Assistant
-    Enter your search request in natural language, and I'll find relevant bookmarked links from your Raindrop.io collection.
+    # 🔍 Raindrop.io Search Assistant
+    Enter your search request in natural language, and I'll find and analyze relevant bookmarked information.
     """)
     
     with gr.Row():
         input_text = gr.Textbox(
             label="What would you like to search for?",
-            placeholder="Ex: blockchain technology",
+            placeholder="Enter your search query here...",
             lines=2
         )
     
@@ -206,7 +223,7 @@ with gr.Blocks(title="Raindrop.io Link Search Assistant", theme=gr.themes.Soft()
     
     with gr.Row():
         output_text = gr.Textbox(
-            label="Search Results",
+            label="Analysis and Results",
             lines=15,
             interactive=False
         )