Update app.py

app.py

@@ -5,7 +5,6 @@ import json
 import os
 from typing import Dict, List
 
-# Get API keys from environment variables
 OPENAI_API_KEY = os.getenv('openaikey')
 RAINDROP_TOKEN = os.getenv('raindroptoken')
 
@@ -21,14 +20,14 @@ class RaindropSearchBot:
         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 = f"""
         Convert the following request into a focused search query for Raindrop.io.
-        The query should be specific and relevant for searching bookmarked links.
+        Extract key concepts and create a search query that will work well with the Raindrop API.
+        Include relevant operators and consider both exact matches and related terms.
         
         User Request: {user_request}
         
-        Format the search query with relevant keywords and operators if needed.
+        Format the search query for maximum relevance and recall.
         """
         
         response = self.client.chat.completions.create(
@@ -38,20 +37,27 @@ class RaindropSearchBot:
             max_tokens=1000
         )
         return response.choices[0].message.content
-    
+
     def search_raindrop(self, search_query: str) -> List[Dict]:
-        """Search Raindrop.io with the generated query."""
         headers = {
             "Authorization": f"Bearer {self.raindrop_api_token}",
             "Content-Type": "application/json"
         }
         
+        # Get all collections first
+        collections_response = requests.get(
+            "https://api.raindrop.io/rest/v1/collections",
+            headers=headers
+        )
+        
         params = {
             "search": search_query,
             "page": 0,
-            "perpage": 10
+            "perpage": 50,  # Increased from 10 to 50
+            "sort": "-created"  # Sort by newest first
         }
         
+        # Search in all collections (0)
         response = requests.get(
             "https://api.raindrop.io/rest/v1/raindrops/0",
             headers=headers,
@@ -59,12 +65,43 @@ class RaindropSearchBot:
         )
         
         if response.status_code == 200:
-            return response.json().get("items", [])
-        else:
-            return []
-    
+            items = response.json().get("items", [])
+            # Get filters to enhance search context
+            filters_response = requests.get(
+                "https://api.raindrop.io/rest/v1/filters/0",
+                headers=headers,
+                params={"search": search_query}
+            )
+            return items
+        return []
+
+    def generate_summary(self, item: Dict) -> str:
+        """Generate a summary for a single bookmark using GPT-4."""
+        content = f"""
+        Title: {item.get('title', 'No Title')}
+        Description: {item.get('excerpt', '')}
+        Tags: {', '.join(item.get('tags', []))}
+        Type: {item.get('type', 'unknown')}
+        """
+        
+        prompt = f"""
+        Please provide a brief, informative summary of this bookmarked content:
+        {content}
+        Keep the summary concise but include key points and relevance.
+        """
+        
+        try:
+            response = self.client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.3,
+                max_tokens=150
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            return "Summary generation failed"
+
     def format_results(self, results: List[Dict]) -> str:
-        """Format the search results into a readable string."""
         if not results:
             return "No results found."
             
@@ -72,24 +109,27 @@ class RaindropSearchBot:
         for idx, item in enumerate(results, 1):
             formatted_output += f"{idx}. {item.get('title', 'No Title')}\n"
             formatted_output += f"   Link: {item.get('link', 'No Link')}\n"
+            
+            # Add tags if present
             if item.get('tags'):
                 formatted_output += f"   Tags: {', '.join(item['tags'])}\n"
+            
+            # Add type and created date
+            formatted_output += f"   Type: {item.get('type', 'unknown')} | Created: {item.get('created', 'unknown')}\n"
+            
+            # Add summary
+            summary = self.generate_summary(item)
+            formatted_output += f"   Summary: {summary}\n"
+            
             formatted_output += "\n"
             
         return formatted_output
     
     def process_request(self, user_request: str) -> str:
-        """Process the user request and return formatted results."""
         try:
-            # Generate optimized search query
             search_query = self.generate_search_query(user_request)
-            
-            # Search Raindrop.io
             results = self.search_raindrop(search_query)
-            
-            # Format and return results
             return self.format_results(results)
-            
         except Exception as e:
             return f"An error occurred: {str(e)}"
 
@@ -104,7 +144,7 @@ def chatbot_interface(user_input: str) -> str:
 with gr.Blocks(title="Raindrop.io Link 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.
+    Enter your search request in natural language, and I'll find and summarize relevant bookmarked links from your Raindrop.io collection.
     """)
     
     with gr.Row():
@@ -120,7 +160,7 @@ with gr.Blocks(title="Raindrop.io Link Search Assistant", theme=gr.themes.Soft()
     with gr.Row():
         output_text = gr.Textbox(
             label="Search Results",
-            lines=10,
+            lines=15,
             interactive=False
         )
     
@@ -134,11 +174,14 @@ with gr.Blocks(title="Raindrop.io Link Search Assistant", theme=gr.themes.Soft()
     ### How to use:
     1. Enter your search request in natural language
     2. Click the Search button
-    3. View the results from your Raindrop.io bookmarks
+    3. View the results and summaries from your Raindrop.io bookmarks
     
-    The assistant will convert your request into an optimized search query and fetch relevant results.
+    The assistant will:
+    - Convert your request into an optimized search query
+    - Search across all your collections
+    - Generate summaries for each result
+    - Present the findings with relevant metadata
     """)
 
-# Launch the interface
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch(share=True)