Fix error handling and result formatting

app.py

@@ -4,7 +4,6 @@ import torch
 import os
 import logging
 import traceback
-import asyncio
 
 # Configure logging
 logging.basicConfig(
@@ -17,7 +16,11 @@ def safe_search(query, max_results):
     """Wrapper function to handle errors gracefully"""
     try:
         rag = RAGEngine()
-        results = asyncio.run(rag.search_and_process(query, max_results))
+        results = rag.search_and_process(query, max_results)
+        
+        if 'error' in results:
+            return f"# ❌ Error\nSorry, an error occurred while processing your search:\n```\n{results['error']}\n```"
+            
         return format_results(results)
     except Exception as e:
         error_msg = f"An error occurred: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
@@ -26,7 +29,7 @@ def safe_search(query, max_results):
 
 def format_results(results):
     """Format search results for display"""
-    if not results:
+    if not results or not results.get('results'):
         return "# ⚠️ No Results\nNo search results were found. Please try a different query."
     
     formatted = f"# 🔍 Search Results\n\n"
@@ -47,63 +50,39 @@ def format_results(results):
     if 'results' in results:
         formatted += "## 📄 Detailed Results\n\n"
         for i, result in enumerate(results['results'], 1):
+            if not isinstance(result, dict):
+                continue
+                
             formatted += f"### {i}. "
             if 'url' in result:
-                formatted += f"[{result.get('title', 'Untitled')}]({result['url']})\n"
-            else:
-                formatted += f"{result.get('title', 'Untitled')}\n"
+                title = result.get('title', 'Untitled')
+                formatted += f"[{title}]({result['url']})\n"
+            if 'summary' in result:
+                formatted += f"\n{result['summary']}\n\n"
                 
-            if result.get('processed_content'):
-                content = result['processed_content']
-                if 'summary' in content:
-                    formatted += f"**Summary:** {content['summary']}\n\n"
-                if content.get('metadata', {}).get('description'):
-                    formatted += f"**Description:** {content['metadata']['description']}\n\n"
-                if content.get('content_type') == 'code':
-                    formatted += f"**Code Analysis:** {content.get('explanation', '')}\n\n"
-                else:
-                    formatted += f"**Detailed Explanation:** {content.get('explanation', '')}\n\n"
-            
-            if 'snippet' in result:
-                formatted += f"**Snippet:** {result['snippet']}\n\n"
-            formatted += "---\n\n"
-    
-    # Add similar queries if available
-    if results.get('similar_queries'):
-        formatted += "## 🔄 Related Searches\n"
-        for query in results['similar_queries']:
-            if isinstance(query, dict) and 'query' in query:
-                formatted += f"- {query['query']}\n"
-            elif isinstance(query, str):
-                formatted += f"- {query}\n"
+    # Add similar chunks if available
+    if 'similar_chunks' in results:
+        formatted += "## 🔍 Related Content\n\n"
+        for i, chunk in enumerate(results['similar_chunks'], 1):
+            if not isinstance(chunk, dict):
+                continue
+                
+            formatted += f"### Related {i}\n"
+            if 'metadata' in chunk:
+                meta = chunk['metadata']
+                if 'title' in meta and 'url' in meta:
+                    formatted += f"From [{meta['title']}]({meta['url']})\n"
+            if 'content' in chunk:
+                formatted += f"\n{chunk['content'][:200]}...\n\n"
     
     return formatted
 
 def create_demo():
     """Create the Gradio interface"""
     
-    # Create cache directory
-    os.makedirs(".cache", exist_ok=True)
-    
-    demo = gr.Blocks(
-        title="AI-Powered Search Engine",
-        css="""
-        .gradio-container {max-width: 1200px !important}
-        .markdown-text {font-size: 16px !important}
-        """
-    )
-    
-    with demo:
-        gr.Markdown("""
-        # 🔍 Intelligent Web Search Engine
-        
-        This advanced search engine uses AI to provide deep understanding of search results:
-        - 🧠 Multi-model AI analysis
-        - 📊 Semantic search and caching
-        - 💡 Automatic insights generation
-        - ❓ Smart follow-up questions
-        - 🔄 Related searches
-        """)
+    with gr.Blocks(title="Web Search + RAG") as demo:
+        gr.Markdown("# 🔍 Intelligent Web Search")
+        gr.Markdown("Search the web with AI-powered insights and analysis.")
         
         with gr.Row():
             with gr.Column():
@@ -113,21 +92,17 @@ def create_demo():
                     lines=2
                 )
                 max_results = gr.Slider(
-                    minimum=3,
+                    minimum=1,
                     maximum=10,
                     value=5,
                     step=1,
-                    label="Maximum Results"
+                    label="Number of Results"
                 )
-                search_btn = gr.Button("🔍 Search", variant="primary")
-            
-        with gr.Column():
-            output = gr.Markdown(
-                label="Results",
-                show_label=False
-            )
+                search_button = gr.Button("🔍 Search")
             
-        search_btn.click(
+        output = gr.Markdown()
+        
+        search_button.click(
             fn=safe_search,
             inputs=[query, max_results],
             outputs=output
@@ -135,17 +110,13 @@ def create_demo():
         
         gr.Examples(
             examples=[
-                ["What are the latest developments in quantum computing?", 5],
-                ["How does Python's asyncio work? Show code examples", 5],
-                ["Explain the transformer architecture in deep learning", 5],
-                ["What are the environmental impacts of renewable energy?", 5]
+                ["What is RAG in AI?", 5],
+                ["Latest developments in quantum computing", 3],
+                ["How does BERT work?", 5]
             ],
-            inputs=[query, max_results],
-            outputs=output,
-            fn=safe_search,
-            cache_examples=True
+            inputs=[query, max_results]
         )
-    
+        
     return demo
 
 # Create the demo

rag_engine.py

@@ -46,22 +46,26 @@ class RAGEngine:
             # Get web search results
             web_results = self.web_search.search(query, max_results)
             
+            if 'error' in web_results:
+                return {'error': web_results['error']}
+            
             # Process and store new content
-            for result in web_results['results']:
-                if 'content' in result:
-                    self.process_and_store_content(
-                        result['content'],
-                        metadata={'url': result.get('url'), 'title': result.get('title')}
-                    )
+            if 'results' in web_results and web_results['results']:
+                for result in web_results['results']:
+                    if 'content' in result:
+                        self.process_and_store_content(
+                            result['content'],
+                            metadata={'url': result.get('url'), 'title': result.get('title')}
+                        )
             
-            # Perform similarity search
+            # Perform similarity search if we have stored vectors
             if self.vector_store:
                 similar_docs = self.vector_store.similarity_search_with_score(
                     query,
                     k=similarity_k
                 )
                 
-                # Add similarity results
+                # Add similarity results to web results
                 web_results['similar_chunks'] = [
                     {
                         'content': doc[0].page_content,
@@ -75,7 +79,7 @@ class RAGEngine:
             
         except Exception as e:
             logger.error(f"Error in search_and_process: {str(e)}")
-            raise
+            return {'error': f"Search failed: {str(e)}"}
 
     def get_relevant_context(self, query: str, k: int = 3) -> List[Dict]:
         """Get most relevant context from vector store"""