Update app.py

app.py

@@ -6,7 +6,7 @@ import json
 import re
 from uuid import uuid4
 from datetime import datetime
-from duckduckgo_search import ddg
+from duckduckgo_search import DDGS  # Corrected import
 from sentence_transformers import SentenceTransformer, util
 from typing import List, Dict, Any, Optional, Union, Tuple
 import logging
@@ -24,7 +24,7 @@ if not HF_API_KEY:
     raise ValueError("Please set the HF_API_KEY environment variable.")
 
 # You can use different models for different tasks
-MAIN_LLM_ENDPOINT = "your-main-llm-endpoint"
+MAIN_LLM_ENDPOINT = "your-main-llm-endpoint"  # Replace with your actual endpoint
 REASONING_LLM_ENDPOINT = "your-reasoning-llm-endpoint"  # Can be the same as main if needed
 CRITIC_LLM_ENDPOINT = "your-critic-llm-endpoint"        # Can be the same as main if needed
 
@@ -48,7 +48,7 @@ except Exception as e:
 def hf_inference(endpoint, inputs, parameters=None, retries=5):
     headers = {"Authorization": f"Bearer {HF_API_KEY}"}
     payload = {"inputs": inputs, "parameters": parameters or {}}
-    
+
     for attempt in range(retries):
         try:
             response = requests.post(endpoint, headers=headers, json=payload, timeout=TIMEOUT)
@@ -61,40 +61,41 @@ def hf_inference(endpoint, inputs, parameters=None, retries=5):
             time.sleep(RETRY_DELAY * (1 + attempt))  # Exponential backoff
     return {"error": "Request failed after multiple retries."}
 
-def tool_search_web(query: str, num_results: int = NUM_RESULTS, safesearch: str = "moderate", 
+def tool_search_web(query: str, num_results: int = NUM_RESULTS, safesearch: str = "moderate",
                     time_filter: str = "", region: str = "wt-wt", language: str = "en-us") -> list:
     try:
-        results = ddg(query, max_results=num_results, safesearch=safesearch, 
-                     time=time_filter, region=region, language=language)
-        if results:
-            return [{"title": r["title"], "snippet": r["snippet"], "url": r["href"]} for r in results]
-        else:
-            return []
+        with DDGS() as ddgs:  # Use the DDGS context manager
+            results = [r for r in ddgs.text(query, max_results=num_results, safesearch=safesearch,
+                                           time=time_filter, region=region, hreflang=language)] #Simplified call
+            if results:
+                return [{"title": r["title"], "snippet": r["body"], "url": r["href"]} for r in results]
+            else:
+                return []
     except Exception as e:
         logger.error(f"DuckDuckGo search error: {e}")
         return []
 
-def tool_reason(prompt: str, search_results: list, reasoning_context: list = [], 
+def tool_reason(prompt: str, search_results: list, reasoning_context: list = [],
                 critique: str = "", focus_areas: list = []) -> str:
     if not search_results:
         return "No search results to reason about."
-    
+
     reasoning_input = "Reason about the following search results in relation to the prompt:\n\n"
     reasoning_input += f"Prompt: {prompt}\n\n"
-    
+
     if focus_areas:
         reasoning_input += f"Focus particularly on these aspects: {', '.join(focus_areas)}\n\n"
-    
+
     for i, result in enumerate(search_results):
         reasoning_input += f"- Result {i + 1}: Title: {result['title']}, Snippet: {result['snippet']}\n"
-    
+
     if reasoning_context:
         recent_context = reasoning_context[-MAX_HISTORY_ITEMS:]
         reasoning_input += "\nPrevious Reasoning Context:\n" + "\n".join(recent_context)
-    
+
     if critique:
         reasoning_input += f"\n\nRecent critique to address: {critique}\n"
-        
+
     reasoning_input += "\nProvide a thorough, nuanced analysis that builds upon previous reasoning if applicable. Consider multiple perspectives and potential contradictions in the search results."
 
     reasoning_output = hf_inference(REASONING_LLM_ENDPOINT, reasoning_input)
@@ -108,15 +109,15 @@ def tool_reason(prompt: str, search_results: list, reasoning_context: list = [],
 def tool_summarize(insights: list, prompt: str, contradictions: list = []) -> str:
     if not insights:
         return "No insights to summarize."
-    
+
     summarization_input = f"Synthesize the following insights into a cohesive and comprehensive summary regarding: '{prompt}'\n\n"
     summarization_input += "\n\n".join(insights[-MAX_HISTORY_ITEMS:])  # Only use most recent insights
-    
+
     if contradictions:
         summarization_input += "\n\nAddress these specific contradictions:\n" + "\n".join(contradictions)
-    
+
     summarization_input += "\n\nProvide a well-structured summary that:\n1. Presents the main findings\n2. Acknowledges limitations and uncertainties\n3. Highlights areas of consensus and disagreement\n4. Suggests potential directions for further inquiry"
-    
+
     summarization_output = hf_inference(MAIN_LLM_ENDPOINT, summarization_input)
 
     if isinstance(summarization_output, dict) and "generated_text" in summarization_output:
@@ -125,120 +126,120 @@ def tool_summarize(insights: list, prompt: str, contradictions: list = []) -> st
         logger.error(f"Failed to generate summary: {summarization_output}")
         return "Could not generate a summary due to an error."
 
-def tool_generate_search_query(prompt: str, previous_queries: list = [], 
+def tool_generate_search_query(prompt: str, previous_queries: list = [],
                               failed_queries: list = [], focus_areas: list = []) -> str:
     query_gen_input = f"Generate an effective search query for the following prompt: {prompt}\n"
-    
+
     if previous_queries:
         recent_queries = previous_queries[-MAX_HISTORY_ITEMS:]
         query_gen_input += "Previous search queries:\n" + "\n".join(recent_queries) + "\n"
-    
+
     if failed_queries:
         query_gen_input += "These queries didn't yield useful results:\n" + "\n".join(failed_queries) + "\n"
-    
+
     if focus_areas:
         query_gen_input += f"Focus particularly on these aspects: {', '.join(focus_areas)}\n"
-    
+
     query_gen_input += "Refine the search query based on previous queries, aiming for more precise results.\n"
     query_gen_input += "Search Query:"
-    
+
     query_gen_output = hf_inference(MAIN_LLM_ENDPOINT, query_gen_input)
 
     if isinstance(query_gen_output, dict) and 'generated_text' in query_gen_output:
         return query_gen_output['generated_text'].strip()
-    
+
     logger.error(f"Failed to generate search query: {query_gen_output}")
     return ""
 
-def tool_critique_reasoning(reasoning_output: str, prompt: str, 
+def tool_critique_reasoning(reasoning_output: str, prompt: str,
                            previous_critiques: list = []) -> str:
     critique_input = f"Critically evaluate the following reasoning output in relation to the prompt:\n\nPrompt: {prompt}\n\nReasoning: {reasoning_output}\n\n"
-    
+
     if previous_critiques:
         critique_input += "Previous critiques that should be addressed:\n" + "\n".join(previous_critiques[-MAX_HISTORY_ITEMS:]) + "\n\n"
-    
+
     critique_input += "Identify any flaws, biases, logical fallacies, unsupported claims, or areas for improvement. Be specific and constructive. Suggest concrete ways to enhance the reasoning."
-    
+
     critique_output = hf_inference(CRITIC_LLM_ENDPOINT, critique_input)
-    
+
     if isinstance(critique_output, dict) and "generated_text" in critique_output:
         return critique_output["generated_text"].strip()
-    
+
     logger.error(f"Failed to generate critique: {critique_output}")
     return "Could not generate a critique due to an error."
 
 def tool_identify_contradictions(insights: list) -> list:
     if len(insights) < 2:
         return []
-    
+
     contradiction_input = "Identify specific contradictions in these insights:\n\n" + "\n\n".join(insights[-MAX_HISTORY_ITEMS:])
     contradiction_input += "\n\nList each contradiction as a separate numbered point. If no contradictions exist, respond with 'No contradictions found.'"
-    
+
     contradiction_output = hf_inference(CRITIC_LLM_ENDPOINT, contradiction_input)
-    
+
     if isinstance(contradiction_output, dict) and "generated_text" in contradiction_output:
         result = contradiction_output["generated_text"].strip()
         if result == "No contradictions found.":
             return []
-        
+
         # Extract numbered contradictions
         contradictions = re.findall(r'\d+\.\s+(.*?)(?=\d+\.|$)', result, re.DOTALL)
         return [c.strip() for c in contradictions if c.strip()]
-    
+
     logger.error(f"Failed to identify contradictions: {contradiction_output}")
     return []
 
-def tool_identify_focus_areas(prompt: str, insights: list = [], 
+def tool_identify_focus_areas(prompt: str, insights: list = [],
                              failed_areas: list = []) -> list:
     focus_input = f"Based on this research prompt: '{prompt}'\n\n"
-    
+
     if insights:
         focus_input += "And these existing insights:\n" + "\n".join(insights[-3:]) + "\n\n"  # Last 3 insights
-    
+
     if failed_areas:
         focus_input += f"These focus areas didn't yield useful results: {', '.join(failed_areas)}\n\n"
-    
+
     focus_input += "Identify 2-3 specific aspects that should be investigated further to get a complete understanding. Be precise and prioritize underexplored areas."
-    
+
     focus_output = hf_inference(MAIN_LLM_ENDPOINT, focus_input)
-    
+
     if isinstance(focus_output, dict) and "generated_text" in focus_output:
         result = focus_output["generated_text"].strip()
         # Extract areas, assuming they're listed with numbers, bullets, or in separate lines
         areas = re.findall(r'(?:^|\n)(?:\d+\.|\*|\-)\s*(.*?)(?=(?:\n(?:\d+\.|\*|\-|$))|$)', result)
         return [area.strip() for area in areas if area.strip()][:3]  # Limit to top 3
-    
+
     logger.error(f"Failed to identify focus areas: {focus_output}")
     return []
 
 def filter_results(search_results, prompt, previous_snippets=None):
     if not main_similarity_model or not search_results:
         return search_results
-    
+
     try:
         prompt_embedding = main_similarity_model.encode(prompt, convert_to_tensor=True)
         filtered_results = []
-        
+
         # Keep track of snippets we've already seen
         seen_snippets = set()
         if previous_snippets:
             seen_snippets.update(previous_snippets)
-        
+
         for result in search_results:
             combined_text = result['title'] + " " + result['snippet']
-            
+
             # Skip if we've seen this exact snippet before
             if result['snippet'] in seen_snippets:
                 continue
-            
+
             result_embedding = main_similarity_model.encode(combined_text, convert_to_tensor=True)
             cosine_score = util.pytorch_cos_sim(prompt_embedding, result_embedding)[0][0].item()
-            
+
             if cosine_score >= SIMILARITY_THRESHOLD:
                 result['relevance_score'] = cosine_score
                 filtered_results.append(result)
                 seen_snippets.add(result['snippet'])
-        
+
         # Sort by relevance score
         filtered_results.sort(key=lambda x: x.get('relevance_score', 0), reverse=True)
         return filtered_results
@@ -250,15 +251,15 @@ def filter_results(search_results, prompt, previous_snippets=None):
 # New tool: Extract entities for focused research
 def tool_extract_key_entities(prompt: str) -> list:
     entity_input = f"Extract the key entities (people, organizations, concepts, technologies, etc.) from this research prompt that should be investigated individually:\n\n{prompt}\n\nList only the most important 3-5 entities, one per line."
-    
+
     entity_output = hf_inference(MAIN_LLM_ENDPOINT, entity_input)
-    
+
     if isinstance(entity_output, dict) and "generated_text" in entity_output:
         result = entity_output["generated_text"].strip()
         # Split by lines and clean up
         entities = [e.strip() for e in result.split('\n') if e.strip()]
         return entities[:5]  # Limit to 5 entities
-    
+
     logger.error(f"Failed to extract key entities: {entity_output}")
     return []
 
@@ -266,20 +267,20 @@ def tool_extract_key_entities(prompt: str) -> list:
 def tool_meta_analyze(entity_insights: Dict[str, list], prompt: str) -> str:
     if not entity_insights:
         return "No entity insights to analyze."
-    
+
     meta_input = f"Perform a meta-analysis across these different entities related to the prompt: '{prompt}'\n\n"
-    
+
     for entity, insights in entity_insights.items():
         if insights:
             meta_input += f"\n--- {entity} ---\n" + insights[-1] + "\n"  # Just use the latest insight for each entity
-    
+
     meta_input += "\nProvide a high-level synthesis that identifies:\n1. Common themes across entities\n2. Important differences\n3. How these entities interact or influence each other\n4. The broader implications for the original research question"
-    
+
     meta_output = hf_inference(MAIN_LLM_ENDPOINT, meta_input)
-    
+
     if isinstance(meta_output, dict) and "generated_text" in meta_output:
         return meta_output["generated_text"].strip()
-    
+
     logger.error(f"Failed to perform meta-analysis: {meta_output}")
     return "Could not generate a meta-analysis due to an error."
 
@@ -384,7 +385,7 @@ Available Tools:
 
     # Only include most recent context items to avoid exceeding context limits
     recent_context = context[-MAX_CONTEXT_ITEMS:] if len(context) > MAX_CONTEXT_ITEMS else context
-    
+
     prompt += "\nContext (most recent items):\n"
     for item in recent_context:
         prompt += f"- {item}\n"
@@ -416,17 +417,17 @@ def deep_research(prompt):
     seen_snippets = set()
     contradictions = []
     research_session_id = str(uuid4())
-    
+
     # Start with entity extraction for multi-pronged research
     key_entities = tool_extract_key_entities(prompt=prompt)
     if key_entities:
         context.append(f"Identified key entities: {key_entities}")
         intermediate_output += f"Identified key entities for focused research: {key_entities}\n"
-    
+
     # Tracking progress for each entity
     entity_progress = {entity: {'queries': [], 'insights': []} for entity in key_entities}
     entity_progress['general'] = {'queries': [], 'insights': []}  # For general research not tied to specific entities
-    
+
     for i in range(MAX_ITERATIONS):
         # Decide which entity to focus on this iteration, or general research
         if key_entities and i > 0:
@@ -435,9 +436,9 @@ def deep_research(prompt):
             current_entity = entities_to_process[i % len(entities_to_process)]
         else:
             current_entity = 'general'
-        
+
         context.append(f"Current focus: {current_entity}")
-        
+
         # First iteration: general query and initial research
         if i == 0:
             initial_query = tool_generate_search_query(prompt=prompt)
@@ -446,10 +447,10 @@ def deep_research(prompt):
                 entity_progress['general']['queries'].append(initial_query)
                 search_results = tool_search_web(query=initial_query)
                 filtered_search_results = filter_results(search_results, prompt)
-                
+
                 for result in filtered_search_results:
                     seen_snippets.add(result['snippet'])
-                
+
                 if filtered_search_results:
                     context.append(f"Initial Search Results: {len(filtered_search_results)} items found")
                     reasoning_output = tool_reason(prompt, filtered_search_results)
@@ -461,7 +462,7 @@ def deep_research(prompt):
                 else:
                     failed_queries.append(initial_query)
                     context.append(f"Initial query yielded no relevant results: {initial_query}")
-        
+
         # Generate current entity-specific query if applicable
         elif current_entity != 'general':
             entity_query = tool_generate_search_query(
@@ -469,24 +470,24 @@ def deep_research(prompt):
                 previous_queries=entity_progress[current_entity]['queries'],
                 focus_areas=focus_areas
             )
-            
+
             if entity_query:
                 previous_queries.append(entity_query)
                 entity_progress[current_entity]['queries'].append(entity_query)
-                
+
                 # Search with entity focus
                 search_results = tool_search_web(query=entity_query)
-                filtered_search_results = filter_results(search_results, 
+                filtered_search_results = filter_results(search_results,
                                                         f"{prompt} {current_entity}",
                                                         previous_snippets=seen_snippets)
-                
+
                 # Update seen snippets
                 for result in filtered_search_results:
                     seen_snippets.add(result['snippet'])
-                
+
                 if filtered_search_results:
                     context.append(f"Entity Search for {current_entity}: {len(filtered_search_results)} results")
-                    
+
                     # Get entity-specific reasoning
                     entity_reasoning = tool_reason(
                         prompt=f"{prompt} focusing on {current_entity}",
@@ -494,29 +495,29 @@ def deep_research(prompt):
                         reasoning_context=entity_progress[current_entity]['insights'],
                         focus_areas=focus_areas
                     )
-                    
+
                     if entity_reasoning:
                         all_insights.append(entity_reasoning)
                         entity_progress[current_entity]['insights'].append(entity_reasoning)
-                        
+
                         # Store in entity-specific insights dictionary for meta-analysis
                         if current_entity not in entity_specific_insights:
                             entity_specific_insights[current_entity] = []
                         entity_specific_insights[current_entity].append(entity_reasoning)
-                        
+
                         context.append(f"Reasoning about {current_entity}: {entity_reasoning[:200]}...")
                 else:
                     failed_queries.append(entity_query)
                     context.append(f"Entity query for {current_entity} yielded no relevant results")
-        
+
         # Generate LLM decision for next tool
         llm_prompt = create_prompt(task_description, prompt, tools, context)
         llm_response = hf_inference(MAIN_LLM_ENDPOINT, llm_prompt)
-        
+
         if isinstance(llm_response, dict) and "error" in llm_response:
             intermediate_output += f"LLM Error: {llm_response['error']}\n"
             continue
-            
+
         if not isinstance(llm_response, dict) or "generated_text" not in llm_response:
             intermediate_output += "Error: Invalid LLM response.\n"
             continue
@@ -554,32 +555,32 @@ def deep_research(prompt):
                 parameters['failed_queries'] = failed_queries
                 parameters['focus_areas'] = focus_areas
                 result = tool["function"](**parameters)
-                
+
                 if current_entity != 'general':
                     entity_progress[current_entity]['queries'].append(result)
-                
+
                 previous_queries.append(result)
-                
+
             elif tool_name == "reason":
                 if current_entity != 'general' and 'reasoning_context' not in parameters:
                     parameters['reasoning_context'] = entity_progress[current_entity]['insights']
                 elif 'reasoning_context' not in parameters:
                     parameters['reasoning_context'] = reasoning_context[:]
-                
+
                 if 'prompt' not in parameters:
                     if current_entity != 'general':
                         parameters['prompt'] = f"{prompt} focusing on {current_entity}"
                     else:
                         parameters['prompt'] = prompt
-                
+
                 if 'search_results' not in parameters:
                     parameters['search_results'] = []
-                    
+
                 if 'focus_areas' not in parameters and focus_areas:
                     parameters['focus_areas'] = focus_areas
-                    
+
                 result = tool["function"](**parameters)
-                
+
                 if current_entity != 'general':
                     entity_progress[current_entity]['insights'].append(result)
                     if current_entity not in entity_specific_insights:
@@ -587,48 +588,48 @@ def deep_research(prompt):
                     entity_specific_insights[current_entity].append(result)
                 else:
                     reasoning_context.append(result)
-                
+
                 all_insights.append(result)
-                
+
             elif tool_name == "search_web":
                 result = tool_search_web(**parameters)
-                filtered_result = filter_results(result, 
+                filtered_result = filter_results(result,
                                                prompt if current_entity == 'general' else f"{prompt} {current_entity}",
                                                previous_snippets=seen_snippets)
-                
+
                 # Update seen snippets
                 for r in filtered_result:
                     seen_snippets.add(r['snippet'])
-                    
+
                 result = filtered_result
-                
+
                 if not result:
                     query = parameters.get('query', '')
                     if query:
                         failed_queries.append(query)
-                
+
             elif tool_name == "critique_reasoning":
                 if 'previous_critiques' not in parameters:
                     parameters['previous_critiques'] = previous_critiques
-                
+
                 if all_insights:
                     if 'reasoning_output' not in parameters:
                         parameters['reasoning_output'] = all_insights[-1]
                     if 'prompt' not in parameters:
                         parameters['prompt'] = prompt
-                        
+
                     result = tool["function"](**parameters)
                     previous_critiques.append(result)
                     context.append(f"Critique: {result[:200]}...")
                 else:
                     result = "No reasoning to critique yet."
-            
+
             elif tool_name == "identify_contradictions":
                 result = tool["function"](**parameters)
                 if result:
                     contradictions = result  # Store for later use in summarization
                     context.append(f"Identified contradictions: {result}")
-            
+
             elif tool_name == "identify_focus_areas":
                 if 'failed_areas' not in parameters:
                     parameters['failed_areas'] = failed_areas
@@ -639,7 +640,7 @@ def deep_research(prompt):
                     focus_areas = result
                     failed_areas.extend([area for area in old_focus if area not in result])
                     context.append(f"New focus areas: {result}")
-            
+
             elif tool_name == "meta_analyze":
                 if 'entity_insights' not in parameters:
                     parameters['entity_insights'] = entity_specific_insights
@@ -649,7 +650,7 @@ def deep_research(prompt):
                 if result:
                     all_insights.append(result)  # Add meta-analysis to insights
                     context.append(f"Meta-analysis across entities: {result[:200]}...")
-            
+
             else:
                 result = tool["function"](**parameters)
 
@@ -657,9 +658,9 @@ def deep_research(prompt):
             result_str = str(result)
             if len(result_str) > 500:
                 result_str = result_str[:500] + "..."
-                
+
             intermediate_output += f"Iteration {i+1} - Result: {result_str}\n"
-            
+
 # Add truncated result to context
             result_context = result_str
             if len(result_str) > 300:  # Even shorter for context
@@ -669,8 +670,7 @@ def deep_research(prompt):
         except Exception as e:
             logger.error(f"Error with {tool_name}: {str(e)}")
             context.append(f"Error with {tool_name}: {str(e)}")
-            intermediate_output += f"Iteration {i+1} - Error: {str(e)}\n"
-            continue
+            intermediate_output += f"Iteration {i+1} - Error: {str(e)}\            continue
 
     # Perform final meta-analysis if we have entity-specific insights
     if len(entity_specific_insights) > 1 and len(all_insights) > 2:
@@ -687,26 +687,26 @@ def deep_research(prompt):
 
     # Prepare the full output with detailed tracking
     full_output = f"**Research Prompt:** {prompt}\n\n"
-    
+
     if key_entities:
         full_output += f"**Key Entities Identified:** {', '.join(key_entities)}\n\n"
-    
+
     full_output += "**Research Process:**\n" + intermediate_output + "\n"
-    
+
     if contradictions:
         full_output += "**Contradictions Identified:**\n"
         for i, contradiction in enumerate(contradictions, 1):
             full_output += f"{i}. {contradiction}\n"
         full_output += "\n"
-    
+
     full_output += f"**Final Analysis:**\n{final_result}\n\n"
-    
+
     # Add session info for potential follow-up
     full_output += f"Research Session ID: {research_session_id}\n"
     full_output += f"Completed at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
     full_output += f"Total iterations: {i+1}\n"
     full_output += f"Total insights generated: {len(all_insights)}\n"
-    
+
     return full_output
 
 # Create CSS for a more professional look
@@ -750,19 +750,20 @@ iface = gr.Interface(
         ["Analyze the environmental and social impacts of lithium mining for electric vehicle batteries."],
         ["How has artificial intelligence influenced medical diagnostics in the past five years, and what are the ethical considerations?"]
     ],
-    theme="default",
+    theme="default",  #  gr.themes.Base() is more explicit, but "default" also works
     css=custom_css,
     allow_flagging=False,
     analytics_enabled=False,
 )
 
-# Add footer with additional information
+# Add footer with additional information (Optional, good for context)
 footer_html = """
 <div class="footer">
     <p>This research assistant performs advanced multi-stage analysis using natural language processing and web search.</p>
     <p>Results should be verified with additional sources. Not suitable for medical, legal, or emergency use.</p>
 </div>
 """
+#iface = iface.add_html(footer_html) #gr.Interface object has no attribute add_html
 
 # Launch the interface
 iface.launch(share=False)