Update app.py

app.py

@@ -1,18 +1,17 @@
 import gradio as gr
-import requests
 import os
 import time
 import json
 import re
 from uuid import uuid4
 from datetime import datetime
-from duckduckgo_search import DDGS  # Corrected import
+from duckduckgo_search import DDGS
 from sentence_transformers import SentenceTransformer, util
 from typing import List, Dict, Any, Optional, Union, Tuple
 import logging
-import pandas as pd
 import numpy as np
 from collections import deque
+from huggingface_hub import InferenceClient
 
 # Set up logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@@ -23,50 +22,54 @@ HF_API_KEY = os.environ.get("HF_API_KEY")
 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 = "'https://router.huggingface.co/hf-inference/models/mistralai/Mistral-Nemo-Instruct-2407/v1/chat/completions"  # Replace with your actual endpoint
-REASONING_LLM_ENDPOINT = "https://router.huggingface.co/hf-inference/models/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B/v1/chat/completions"  # Can be the same as main if needed
-CRITIC_LLM_ENDPOINT = "https://router.huggingface.co/hf-inference/models/Qwen/QwQ-32B-Preview/v1/chat/completions"        # Can be the same as main if needed
+# Initialize Hugging Face Inference Client
+client = InferenceClient(provider="hf-inference", api_key=HF_API_KEY)
 
-MAX_ITERATIONS = 12  # Increased from 7
+# Model endpoints
+MAIN_LLM_MODEL = "mistralai/Mistral-Nemo-Instruct-2407"
+REASONING_LLM_MODEL = "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"
+CRITIC_LLM_MODEL = "Qwen/QwQ-32B-Preview"
+
+MAX_ITERATIONS = 12
 TIMEOUT = 60
 RETRY_DELAY = 5
-NUM_RESULTS = 10     # Increased from 7
-SIMILARITY_THRESHOLD = 0.15  # Lowered from 0.2 to get more potentially relevant results
-MAX_CONTEXT_ITEMS = 20  # Prevent context from growing too large
-MAX_HISTORY_ITEMS = 5   # For keeping track of previous queries/reasoning
+NUM_RESULTS = 10
+SIMILARITY_THRESHOLD = 0.15
+MAX_CONTEXT_ITEMS = 20
+MAX_HISTORY_ITEMS = 5
 
 # Load multiple embedding models for different purposes
 try:
     main_similarity_model = SentenceTransformer('all-mpnet-base-v2')
-    concept_similarity_model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')  # Faster, lighter model for concept matching
+    concept_similarity_model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
 except Exception as e:
     logger.error(f"Failed to load SentenceTransformer models: {e}")
     main_similarity_model = None
     concept_similarity_model = None
 
-def hf_inference(endpoint, inputs, parameters=None, retries=5):
-    headers = {"Authorization": f"Bearer {HF_API_KEY}"}
-    payload = {"inputs": inputs, "parameters": parameters or {}}
-
+def hf_inference(model_name, prompt, max_tokens=500, retries=5):
     for attempt in range(retries):
         try:
-            response = requests.post(endpoint, headers=headers, json=payload, timeout=TIMEOUT)
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
+            messages = [{"role": "user", "content": prompt}]
+            response = client.chat.completions.create(
+                model=model_name,
+                messages=messages,
+                max_tokens=max_tokens
+            )
+            return {"generated_text": response.choices[0].message.content}
+        except Exception as e:
             if attempt == retries - 1:
                 logger.error(f"Request failed after {retries} retries: {e}")
                 return {"error": f"Request failed after {retries} retries: {e}"}
-            time.sleep(RETRY_DELAY * (1 + attempt))  # Exponential backoff
+            time.sleep(RETRY_DELAY * (1 + attempt))
     return {"error": "Request failed after multiple retries."}
 
 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:
-        with DDGS() as ddgs:  # Use the DDGS context manager
+        with DDGS() as ddgs:
             results = [r for r in ddgs.text(query, max_results=num_results, safesearch=safesearch,
-                                           time=time_filter, region=region, hreflang=language)] #Simplified call
+                                           time=time_filter, region=region, hreflang=language)]
             if results:
                 return [{"title": r["title"], "snippet": r["body"], "url": r["href"]} for r in results]
             else:
@@ -98,7 +101,7 @@ def tool_reason(prompt: str, search_results: list, reasoning_context: list = [],
 
     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)
+    reasoning_output = hf_inference(REASONING_LLM_MODEL, reasoning_input)
 
     if isinstance(reasoning_output, dict) and "generated_text" in reasoning_output:
         return reasoning_output["generated_text"].strip()
@@ -111,14 +114,14 @@ def tool_summarize(insights: list, prompt: str, contradictions: list = []) -> st
         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
+    summarization_input += "\n\n".join(insights[-MAX_HISTORY_ITEMS:])
 
     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)
+    summarization_output = hf_inference(MAIN_LLM_MODEL, summarization_input)
 
     if isinstance(summarization_output, dict) and "generated_text" in summarization_output:
         return summarization_output["generated_text"].strip()
@@ -127,7 +130,7 @@ def tool_summarize(insights: list, prompt: str, contradictions: list = []) -> st
         return "Could not generate a summary due to an error."
 
 def tool_generate_search_query(prompt: str, previous_queries: list = [],
-                              failed_queries: list = [], focus_areas: list = []) -> str:
+                               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:
@@ -143,7 +146,7 @@ def tool_generate_search_query(prompt: str, previous_queries: list = [],
     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)
+    query_gen_output = hf_inference(MAIN_LLM_MODEL, query_gen_input)
 
     if isinstance(query_gen_output, dict) and 'generated_text' in query_gen_output:
         return query_gen_output['generated_text'].strip()
@@ -152,7 +155,7 @@ def tool_generate_search_query(prompt: str, previous_queries: list = [],
     return ""
 
 def tool_critique_reasoning(reasoning_output: str, prompt: str,
-                           previous_critiques: list = []) -> 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:
@@ -160,7 +163,7 @@ def tool_critique_reasoning(reasoning_output: str, prompt: str,
 
     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)
+    critique_output = hf_inference(CRITIC_LLM_MODEL, critique_input)
 
     if isinstance(critique_output, dict) and "generated_text" in critique_output:
         return critique_output["generated_text"].strip()
@@ -175,14 +178,13 @@ def tool_identify_contradictions(insights: list) -> list:
     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)
+    contradiction_output = hf_inference(CRITIC_LLM_MODEL, 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()]
 
@@ -190,24 +192,23 @@ def tool_identify_contradictions(insights: list) -> list:
     return []
 
 def tool_identify_focus_areas(prompt: str, insights: list = [],
-                             failed_areas: list = []) -> 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
+        focus_input += "And these existing insights:\n" + "\n".join(insights[-3:]) + "\n\n"
 
     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)
+    focus_output = hf_inference(MAIN_LLM_MODEL, 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
+        return [area.strip() for area in areas if area.strip()][:3]
 
     logger.error(f"Failed to identify focus areas: {focus_output}")
     return []
@@ -220,7 +221,6 @@ def filter_results(search_results, prompt, previous_snippets=None):
         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)
@@ -228,7 +228,6 @@ def filter_results(search_results, prompt, previous_snippets=None):
         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
 
@@ -240,7 +239,6 @@ def filter_results(search_results, prompt, previous_snippets=None):
                 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
 
@@ -248,22 +246,19 @@ def filter_results(search_results, prompt, previous_snippets=None):
         logger.error(f"Error during filtering: {e}")
         return search_results
 
-# 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)
+    entity_output = hf_inference(MAIN_LLM_MODEL, 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
+        return entities[:5]
 
     logger.error(f"Failed to extract key entities: {entity_output}")
     return []
 
-# New tool: Meta-analyze across entities
 def tool_meta_analyze(entity_insights: Dict[str, list], prompt: str) -> str:
     if not entity_insights:
         return "No entity insights to analyze."
@@ -272,11 +267,11 @@ def tool_meta_analyze(entity_insights: Dict[str, list], prompt: str) -> str:
 
     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 += f"\n--- {entity} ---\n" + insights[-1] + "\n"
 
     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)
+    meta_output = hf_inference(MAIN_LLM_MODEL, meta_input)
 
     if isinstance(meta_output, dict) and "generated_text" in meta_output:
         return meta_output["generated_text"].strip()
@@ -284,7 +279,6 @@ def tool_meta_analyze(entity_insights: Dict[str, list], prompt: str) -> str:
     logger.error(f"Failed to perform meta-analysis: {meta_output}")
     return "Could not generate a meta-analysis due to an error."
 
-# Update tools dictionary with enhanced functionality
 tools = {
     "search_web": {
         "function": tool_search_web,
@@ -371,10 +365,8 @@ tools = {
 
 def create_prompt(task_description, user_input, available_tools, context):
     prompt = f"""{task_description}
-
 User Input:
 {user_input}
-
 Available Tools:
 """
     for tool_name, tool_data in available_tools.items():
@@ -383,7 +375,6 @@ Available Tools:
         for param_name, param_data in tool_data["parameters"].items():
             prompt += f"    - {param_name} ({param_data['type']}): {param_data['description']}\n"
 
-    # 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"
@@ -394,10 +385,8 @@ Available Tools:
 Instructions:
 Select the BEST tool and parameters for the current research stage. Output valid JSON. If no tool is appropriate, respond with {}.
 Only use provided tools. Be strategic about which tool to use next based on the research progress so far.
-
 Example:
 {"tool": "search_web", "parameters": {"query": "Eiffel Tower location"}}
-
 Output:
 """
     return prompt
@@ -418,20 +407,16 @@ def deep_research(prompt):
     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
+    entity_progress['general'] = {'queries': [], 'insights': []}
 
     for i in range(MAX_ITERATIONS):
-        # Decide which entity to focus on this iteration, or general research
         if key_entities and i > 0:
-            # Simple round-robin for entities, with general research every few iterations
             entities_to_process = key_entities + ['general']
             current_entity = entities_to_process[i % len(entities_to_process)]
         else:
@@ -439,7 +424,6 @@ def deep_research(prompt):
 
         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)
             if initial_query:
@@ -463,7 +447,6 @@ def deep_research(prompt):
                     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(
                 prompt=f"{prompt} focusing specifically on {current_entity}",
@@ -475,20 +458,17 @@ def deep_research(prompt):
                 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,
                                                         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}",
                         search_results=filtered_search_results,
@@ -500,7 +480,6 @@ def deep_research(prompt):
                         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)
@@ -510,9 +489,8 @@ def deep_research(prompt):
                     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)
+        llm_response = hf_inference(MAIN_LLM_MODEL, llm_prompt)
 
         if isinstance(llm_response, dict) and "error" in llm_response:
             intermediate_output += f"LLM Error: {llm_response['error']}\n"
@@ -536,8 +514,7 @@ def deep_research(prompt):
 
         if not tool_name:
             if all_insights:
-                # If we have insights but no tool selected, maybe we're done
-                if i > MAX_ITERATIONS // 2:  # Only consider ending early after half the iterations
+                if i > MAX_ITERATIONS // 2:
                     break
             continue
 
@@ -597,7 +574,6 @@ def deep_research(prompt):
                                                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'])
 
@@ -627,7 +603,7 @@ def deep_research(prompt):
             elif tool_name == "identify_contradictions":
                 result = tool["function"](**parameters)
                 if result:
-                    contradictions = result  # Store for later use in summarization
+                    contradictions = result
                     context.append(f"Identified contradictions: {result}")
 
             elif tool_name == "identify_focus_areas":
@@ -635,7 +611,6 @@ def deep_research(prompt):
                     parameters['failed_areas'] = failed_areas
                 result = tool["function"](**parameters)
                 if result:
-                    # Update focus areas, but keep track of ones that didn't yield results
                     old_focus = set(focus_areas)
                     focus_areas = result
                     failed_areas.extend([area for area in old_focus if area not in result])
@@ -648,45 +623,40 @@ def deep_research(prompt):
                     parameters['prompt'] = prompt
                 result = tool["function"](**parameters)
                 if result:
-                    all_insights.append(result)  # Add meta-analysis to insights
+                    all_insights.append(result)
                     context.append(f"Meta-analysis across entities: {result[:200]}...")
 
             else:
                 result = tool["function"](**parameters)
 
-            # Truncate very long results for the intermediate output
             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
+            if len(result_str) > 300:
                 result_context = result_str[:300] + "..."
             context.append(f"Used: {tool_name}, Result: {result_context}")
 
         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"  # Added \n and closing quote
+            intermediate_output += f"Iteration {i+1} - Error: {str(e)}\n"
             continue
 
-    # Perform final meta-analysis if we have entity-specific insights
     if len(entity_specific_insights) > 1 and len(all_insights) > 2:
         meta_analysis = tool_meta_analyze(entity_insights=entity_specific_insights, prompt=prompt)
         if meta_analysis:
             all_insights.append(meta_analysis)
             intermediate_output += f"Final Meta-Analysis: {meta_analysis[:500]}...\n"
 
-    # Generate the final summary
     if all_insights:
         final_result = tool_summarize(all_insights, prompt, contradictions)
     else:
         final_result = "Could not find meaningful information despite multiple attempts."
 
-    # Prepare the full output with detailed tracking
     full_output = f"**Research Prompt:** {prompt}\n\n"
 
     if key_entities:
@@ -702,7 +672,6 @@ def deep_research(prompt):
 
     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"
@@ -752,7 +721,7 @@ iface = gr.Interface(
         ["How has artificial intelligence influenced medical diagnostics in the past five years, and what are the ethical considerations?"]
     ],
     theme="default",
-    cache_examples=False,  # Add this line #  gr.themes.Base() is more explicit, but "default" also works
+    cache_examples=False,
     css=custom_css,
     flagging_mode='never',
     analytics_enabled=False,
@@ -765,7 +734,7 @@ footer_html = """
     <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)