brave

app.py

@@ -10,7 +10,7 @@ from typing import List, Dict, Any, Annotated
 from langgraph.graph import Graph, StateGraph
 from typing_extensions import TypedDict
 from openai import OpenAI
-from urllib.parse import quote_plus
+from tools import smart_search
 
 # -------------------------
 # Utility helpers
@@ -29,82 +29,10 @@ def merge_dicts(old: Dict, new: Dict) -> Dict:
 
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-JINA_API_KEY = os.getenv("JINA_API_KEY")
+BRAVE_KEY = os.getenv("BRAVE_API_KEY") or ""   # set in HF Space secrets
 
 # Remove logs directory creation since we're not storing logs anymore
 
-# -------------------------
-# Jina AI search tool (replaces DDG + Reader)
-# -------------------------
-
-def jina_search_tool(query: str, api_key: str, max_results: int = 5) -> List[str]:
-    """Return *max_results* clean markdown snippets for *query* using s.jina.ai."""
-    print("\n=== Jina Search Debug ===")
-    print(f"Query: {query}")
-    print(f"Max Results: {max_results}")
-    
-    url = f"https://s.jina.ai/?q={quote_plus(query)}"
-    print(f"URL: {url}")
-    
-    headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Accept": "application/json",
-        "User-Agent": "Mozilla/5.0"
-    }
-    print("Headers:", {k: v[:10] + "..." if k == "Authorization" else v for k, v in headers.items()})
-    
-    try:
-        print("\nSending request to Jina API...")
-        r = requests.get(url, headers=headers, timeout=15)
-        print(f"Response Status: {r.status_code}")
-        
-        r.raise_for_status()
-        data = r.json()
-        
-        print("\nResponse Data Structure:")
-        print(f"Keys in response: {list(data.keys())}")
-        print(f"Number of results: {len(data.get('results', []))}")
-        
-        results = [
-            f"{item['title']} – {item['url']}\n{item['content']}"
-            for item in data.get("results", [])[:max_results]
-        ]
-        
-        print(f"\nRetrieved {len(results)} results")
-        if results:
-            print("\nFirst result preview:")
-            print(results[0][:200] + "..." if len(results[0]) > 200 else results[0])
-        
-        if not results:
-            print("WARNING: No results found in the response")
-            print("Full response data:", json.dumps(data, indent=2)[:1000])
-        
-        return results
-        
-    except requests.exceptions.Timeout:
-        print("ERROR: Request timed out after 15 seconds")
-        raise
-    except requests.exceptions.RequestException as e:
-        print(f"ERROR: Network/Request error: {str(e)}")
-        raise
-    except json.JSONDecodeError as e:
-        print(f"ERROR: Failed to parse JSON response: {str(e)}")
-        print(f"Raw response: {r.text[:500]}")
-        raise
-    except Exception as e:
-        print(f"ERROR: Unexpected error: {str(e)}")
-        raise
-
-# -------------------------
-# Logging helper
-# -------------------------
-
-def log_to_file(task_id: str, question: str, log_data: Dict[str, Any]):
-    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
-    filename = os.path.join(LOGS_DIR, f"question_{task_id}_{ts}.json")
-    with open(filename, "w", encoding="utf-8") as f:
-        json.dump({"task_id": task_id, "question": question, "timestamp": ts, "logs": log_data}, f, indent=2)
-
 # -------------------------
 # State definition
 # -------------------------
@@ -127,8 +55,6 @@ class BasicAgent:
     def __init__(self):
         if not OPENAI_API_KEY:
             raise EnvironmentError("OPENAI_API_KEY not set")
-        if not JINA_API_KEY:
-            raise EnvironmentError("JINA_API_KEY not set")
         self.llm = OpenAI(api_key=OPENAI_API_KEY)
         self.workflow = self._build_workflow()
 
@@ -172,7 +98,7 @@ class BasicAgent:
 
     def _perform_search(self, state: AgentState) -> AgentState:
         try:
-            results = jina_search_tool(state["search_query"], JINA_API_KEY)
+            results = smart_search(state["search_query"], BRAVE_KEY, max_results=5)
         except Exception as e:
             results = [f"SEARCH_ERROR: {e}"]
         state["history"].append({"step": "search", "results": results})

tools.py

@@ -2,27 +2,63 @@ from typing import List
 from duckduckgo_search import DDGS
 import requests
 import os
+import json
+import time
+from urllib.parse import quote_plus
+import re
 
 # --- Simple Search Tool ---
 
-def simple_search(query: str, max_results: int = 3) -> List[str]:
-    """
-    Perform a DuckDuckGo search and return a list of strings summarizing the top results.
-    """
-    with DDGS() as ddgs:
-        raw_results = list(ddgs.text(query, max_results=max_results))
+def tighten(question: str) -> str:
+    """Extract key terms from verbose questions to improve search results."""
+    print("\n=== Query Tightening ===")
+    print(f"Original query: {question}")
+    
+    # Find quoted phrases
+    quoted = re.findall(r'"([^"]+)"', question)
+    print(f"Quoted phrases: {quoted}")
+    
+    # Find capitalized terms
+    caps = re.findall(r'\b([A-Z0-9][\w-]{2,})', question)
+    print(f"Capitalized terms: {caps}")
+    
+    # Combine and clean
+    short = " ".join(quoted + caps)
+    result = short or question
+    print(f"Tightened query: {result}")
+    
+    return result
 
-    results = []
-    for r in raw_results:
-        try:
-            title = r.get("title", "")
-            link = r.get("href") or r.get("link", "")
-            summary = f"{title} - {link}"
-            results.append(summary)
-        except Exception as e:
-            print("Skipping malformed search result:", r, "Error:", e)
-
-    return results
+def simple_search(query: str, max_results: int = 3) -> List[str]:
+    """Fallback to DuckDuckGo search."""
+    print("\n=== DuckDuckGo Search Debug ===")
+    print(f"Query: {query}")
+    print(f"Max Results: {max_results}")
+    
+    try:
+        with DDGS() as ddgs:
+            raw = list(ddgs.text(query, max_results=max_results))
+        print(f"Retrieved {len(raw)} raw results")
+        
+        out = []
+        for r in raw:
+            try:
+                result = f"{r.get('title','')} – {r.get('href') or r.get('link','')}"
+                out.append(result)
+                print(f"Processed result: {result[:100]}...")
+            except Exception as e:
+                print(f"Error processing result: {e}")
+                pass
+        
+        print(f"\nFinal results count: {len(out)}")
+        if out:
+            print("\nFirst result preview:")
+            print(out[0][:200] + "..." if len(out[0]) > 200 else out[0])
+        
+        return out
+    except Exception as e:
+        print(f"ERROR in DuckDuckGo search: {str(e)}")
+        raise
 
 # --- Jina Search Tool ---
 
@@ -49,3 +85,95 @@ def jina_search_tool(query: str, api_key: str) -> List[str]:
     except Exception as e:
         print(f"Error fetching search results: {e}")
         return []
+
+def brave_search(query: str, api_key: str, max_results: int = 5) -> List[str]:
+    """
+    Query Brave Web Search API and return a list of 'title – url\\nbody' strings.
+    """
+    print("\n=== Brave Search Debug ===")
+    print(f"Query: {query}")
+    print(f"Max Results: {max_results}")
+    
+    if not api_key:
+        print("ERROR: BRAVE_API_KEY not set")
+        raise RuntimeError("BRAVE_API_KEY not set")
+
+    url = (
+        "https://api.search.brave.com/res/v1/web/search?"
+        f"q={quote_plus(query)}&count={max_results}"
+    )
+    print(f"URL: {url}")
+    
+    hdrs = {
+        "X-Subscription-Token": api_key,
+        "Accept": "application/json",
+        "User-Agent": "Mozilla/5.0",
+    }
+    print("Headers:", {k: v[:10] + "..." if k == "X-Subscription-Token" else v for k, v in hdrs.items()})
+    
+    try:
+        print("\nSending request to Brave API...")
+        r = requests.get(url, headers=hdrs, timeout=12)
+        print(f"Response Status: {r.status_code}")
+        
+        if r.status_code == 429:
+            print("Rate limit hit, waiting 2 seconds and retrying...")
+            time.sleep(2)
+            r = requests.get(url, headers=hdrs, timeout=12)
+            print(f"Retry Response Status: {r.status_code}")
+        
+        r.raise_for_status()
+        data = r.json().get("web", {}).get("results", [])
+        
+        print("\nResponse Data Structure:")
+        print(f"Number of results: {len(data)}")
+        
+        results = [
+            f"{d['title']} – {d['url']}\n{d['body']}"
+            for d in data
+        ][:max_results]
+        
+        print(f"\nRetrieved {len(results)} results")
+        if results:
+            print("\nFirst result preview:")
+            print(results[0][:200] + "..." if len(results[0]) > 200 else results[0])
+        
+        if not results:
+            print("WARNING: No results found in the response")
+            print("Full response data:", json.dumps(r.json(), indent=2)[:1000])
+        
+        return results
+        
+    except requests.exceptions.Timeout:
+        print("ERROR: Request timed out after 12 seconds")
+        raise
+    except requests.exceptions.RequestException as e:
+        print(f"ERROR: Network/Request error: {str(e)}")
+        raise
+    except json.JSONDecodeError as e:
+        print(f"ERROR: Failed to parse JSON response: {str(e)}")
+        print(f"Raw response: {r.text[:500]}")
+        raise
+    except Exception as e:
+        print(f"ERROR: Unexpected error: {str(e)}")
+        raise
+
+def smart_search(query: str, api_key: str, max_results: int = 5) -> List[str]:
+    """
+    1) Brave (if key + quota OK) → 2) DuckDuckGo.
+    """
+    print("\n=== Smart Search Debug ===")
+    print(f"Original query: {query}")
+    
+    # Tighten the query before searching
+    query = tighten(query)
+    print(f"Tightened query: {query}")
+    print(f"Max Results: {max_results}")
+    
+    try:
+        print("Attempting Brave search first...")
+        return brave_search(query, api_key, max_results)
+    except Exception as e:
+        print(f"Brave search failed: {e}")
+        print("Falling back to DuckDuckGo...")
+        return simple_search(query, max_results)