Update app.py

app.py

@@ -513,33 +513,135 @@ class RaindropSearchBot:
                 ref_counter += 1
 
         return output
-
+    
     def process_request(self, user_request: str) -> str:
-        """Process user request with improved error handling"""
+        """
+        Process user request with improved error handling and query generation.
+        
+        Args:
+            user_request (str): The user's original search request
+            
+        Returns:
+            str: Formatted results and analysis
+        """
         try:
-            # Generate search queries
-            search_queries = self.generate_search_queries(user_request)
+            # Generate optimized search query
+            search_query = self.generate_search_queries(user_request)
+            logger.info(f"Processing request: {search_query}")
             
-            # Get results with fallback
-            google_results = self.search_with_fallback(search_queries)
+            # Get search results with fallback
+            google_results = self.search_with_fallback(search_query)
             
             # Add delay before news API call
             self.random_delay()
             
-            news_results = self.get_news_results(search_queries)
+            # Get news results
+            news_results = self.get_news_results(search_query)
             
-            # Process results
+            # Process all results
             processed_results = self.process_all_results([], google_results, news_results)
             
             # Generate response
             essay = self.generate_essay_response(processed_results, user_request)
             
+            # Format and return results
             return self.format_results(processed_results, essay)
             
         except Exception as e:
             logger.error(f"Error processing request: {e}")
-            return "An error occurred while processing your request. Please try again later."
+            return f"""
+            An error occurred while processing your request: {str(e)}
+            
+            Please try again with a different search query or contact support if the problem persists.
+            """
+
+    def generate_search_queries(self, user_request: str) -> str:
+        """
+        Generate optimized search queries from user request.
+        
+        Args:
+            user_request (str): The original user query
+            
+        Returns:
+            str: Optimized search query
+        """
+        try:
+            # Clean and preprocess the user request
+            cleaned_request = self.preprocess_query(user_request)
+            
+            # Generate search query using GPT
+            prompt = f"""
+            Convert this search request into an optimized search query using proper search operators.
+            Request: {cleaned_request}
+            
+            Guidelines:
+            - Focus on key concepts and synonyms
+            - Use combination of keywords that would appear in titles or descriptions
+            - Return only the search terms, no explanation
+            - Include alternative phrasings
+            - Keep it concise (max 6-8 key terms/phrases)
+            - use the formatting authorised in raindrop search:
+                o use " for exact search (ex: "artificial intelligence")
+                o use - to exclude some terms (ex: -math) // Do not exclude terms that are potentially relevant
+                o use match:OR for alternatives (ex: apple match:OR banana )
+                o use match:AND for inclusion of both cases systematically (ex: apple match:AND banana )
+                o use parenthesis for combinations ( ex: sugar match:AND (banana match:OR apple) )
+    
+            Example elaborate request: ("artificial intelligence" match:OR AI) -"machine learning"
+            Use your judgement, think step by steps.
+            Return only the search query terms.
+            """
+            
+            response = self.client.chat.completions.create(
+                model="gpt-4-mini",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.3,
+                max_tokens=100
+            )
+            
+            optimized_query = response.choices[0].message.content.strip()
+            logger.info(f"Generated search query: {optimized_query}")
+            
+            return optimized_query
+            
+        except Exception as e:
+            logger.error(f"Error generating search queries: {e}")
+            # Fallback to using the original request if query generation fails
+            return user_request
 
+    def preprocess_query(self, query: str) -> str:
+        """
+        Preprocess the user query to remove unnecessary elements and standardize format.
+        
+        Args:
+            query (str): Original query string
+            
+        Returns:
+            str: Cleaned query string
+        """
+        try:
+            # Convert to lowercase
+            query = query.lower()
+            
+            # Remove extra whitespace
+            query = ' '.join(query.split())
+            
+            # Remove special characters except basic punctuation
+            query = re.sub(r'[^a-z0-9\s\'".,?!-]', '', query)
+            
+            # Remove multiple punctuation marks
+            query = re.sub(r'([.,?!])\1+', r'\1', query)
+            
+            # Ensure proper spacing around quotes
+            query = re.sub(r'(?<=[^\s])"', ' "', query)
+            query = re.sub(r'"(?=[^\s])', '" ', query)
+            
+            return query
+            
+        except Exception as e:
+            logger.error(f"Error preprocessing query: {e}")
+            return query
+    
     def generate_search_query(self, user_request: str) -> str:
         """Convert user request to optimized search terms."""
         logger.info(f"Generating search query for: {user_request}")