feat: remove Semantic Scholar; add keyless providers Europe PMC, PubMed, Unpaywall, Wikipedia, Wikidata for verification, gaps, and novelty

agents/citation_gap_agent.py

@@ -5,7 +5,6 @@ Output: CitationGap nodes + SuggestedPaper nodes (with direct links)
 """
 from typing import Any, Dict, List
 from agents.base_agent import BaseAgent, AgentContext
-from tools.search_tool import SemanticScholarTool
 from services.paper_recommender import PaperRecommender
 from utils.helpers import generate_id
 
@@ -20,17 +19,11 @@ class CitationGapAgent(BaseAgent):
 
     def __init__(self):
         super().__init__()
-        self._search_tool = None
         self._recommender = None
 
-    def _get_search_tool(self) -> SemanticScholarTool:
-        if self._search_tool is None:
-            self._search_tool = SemanticScholarTool()
-        return self._search_tool
-
     def _get_recommender(self) -> PaperRecommender:
         if self._recommender is None:
-            self._recommender = PaperRecommender(self._get_search_tool())
+            self._recommender = PaperRecommender()
         return self._recommender
 
     async def execute(self, ctx: AgentContext) -> Dict[str, Any]:
@@ -63,22 +56,22 @@ class CitationGapAgent(BaseAgent):
             self.logger.warning("No keywords found; skipping citation gap analysis")
             return {"gap_count": 0}
 
-        # 3. Search Semantic Scholar for each top keyword
-        search_tool = self._get_search_tool()
+        # 3. Search keyless academic providers for each top keyword
+        recommender = self._get_recommender()
         all_found_papers = []
         query_terms = keywords[:5]  # limit API calls
 
         for term in query_terms:
-            result = await search_tool.run(query=term, limit=5)
-            if result.success and result.data:
-                all_found_papers.extend(result.data)
+            found = await recommender.search_web(
+                term, limit=5, keywords=keywords
+            )
+            all_found_papers.extend(found)
 
         # 4. Use LLM to identify gaps (Graph-RAG context: keywords + refs only)
         gaps = await self._identify_gaps(ctx, keywords, existing_refs, all_found_papers)
 
         # 4b. For every gap, search the web for similar papers and recommend
         #     direct links the researcher can open and cite.
-        recommender = self._get_recommender()
         for gap in gaps:
             recs = await recommender.recommend(
                 gap.get("description", ""), doc_keywords=keywords, limit=3

agents/claim_verifier_agent.py

@@ -1,7 +1,9 @@
 """
 Claim Verifier Agent (Wave 3 — runs after ClaimAgent)
-For each extracted claim, searches Semantic Scholar and Tavily for supporting
-or contradicting evidence, then asks the LLM to classify the claim as:
+For each extracted claim, searches keyless academic providers (Europe PMC,
+PubMed), web recommender sources (OpenAlex/Crossref/arXiv), Wikipedia and
+Wikidata for supporting or contradicting evidence, then asks the LLM to
+classify the claim as:
   SUPPORTED | CONTRADICTED | UNVERIFIED
 
 Results are stored on the Claim node in Neo4j and returned for the
@@ -13,8 +15,9 @@ from typing import Any, Dict, List, Optional
 from agents.base_agent import BaseAgent, AgentContext
 from services.paper_recommender import PaperRecommender, clean_title, extract_query
 from tools.ddg_tool import DuckDuckGoTool
-from tools.search_tool import SemanticScholarTool
+from tools.search_tool import EuropePMCTool, PubMedTool
 from tools.tavily_tool import TavilyTool
+from tools.wikipedia_tool import WikipediaTool, WikidataTool
 from utils.logger import get_logger
 
 VERIFY_SYSTEM = """You are a scientific fact-checker.
@@ -47,15 +50,23 @@ class ClaimVerifierAgent(BaseAgent):
 
     def __init__(self):
         super().__init__()
-        self._ss_tool = None
+        self._epmc_tool = None
+        self._pubmed_tool = None
         self._tavily_tool = None
         self._ddg_tool = None
+        self._wiki_tool = None
+        self._wikidata_tool = None
         self._rec_tool = None
 
-    def _ss(self) -> SemanticScholarTool:
-        if self._ss_tool is None:
-            self._ss_tool = SemanticScholarTool()
-        return self._ss_tool
+    def _epmc(self) -> EuropePMCTool:
+        if self._epmc_tool is None:
+            self._epmc_tool = EuropePMCTool()
+        return self._epmc_tool
+
+    def _pubmed(self) -> PubMedTool:
+        if self._pubmed_tool is None:
+            self._pubmed_tool = PubMedTool()
+        return self._pubmed_tool
 
     def _tavily(self) -> TavilyTool:
         if self._tavily_tool is None:
@@ -67,6 +78,16 @@ class ClaimVerifierAgent(BaseAgent):
             self._ddg_tool = DuckDuckGoTool()
         return self._ddg_tool
 
+    def _wiki(self) -> WikipediaTool:
+        if self._wiki_tool is None:
+            self._wiki_tool = WikipediaTool()
+        return self._wiki_tool
+
+    def _wikidata(self) -> WikidataTool:
+        if self._wikidata_tool is None:
+            self._wikidata_tool = WikidataTool()
+        return self._wikidata_tool
+
     def _get_recommender(self) -> PaperRecommender:
         if self._rec_tool is None:
             self._rec_tool = PaperRecommender()
@@ -196,7 +217,8 @@ class ClaimVerifierAgent(BaseAgent):
         self, claim_text: str, doc_keywords: Optional[List[str]] = None
     ) -> List[Dict]:
         """
-        Evidence chain: Semantic Scholar → OpenAlex/Crossref/arXiv → Tavily → DDG.
+        Evidence chain: Europe PMC → PubMed → OpenAlex/Crossref/arXiv →
+        Wikipedia → Wikidata → Tavily → DDG.
         Queries are topic-based (document keywords + claim key terms), since
         full claim sentences make poor search queries.
         """
@@ -221,13 +243,21 @@ class ClaimVerifierAgent(BaseAgent):
         queries = list(dict.fromkeys(q for q in (topic_query, claim_query) if q))
         if not queries:
             queries = [claim_text[:100]]
+        web_query = claim_query or topic_query or queries[0]
 
-        # 1. Semantic Scholar on the claim topic
-        ss_result = await self._ss().run(query=queries[0], limit=5)
-        if ss_result.success and ss_result.data:
-            for p in ss_result.data:
+        # 1. Keyless biomedical providers on the claim topic
+        epmc_result = await self._epmc().run(query=queries[0], limit=4)
+        if epmc_result.success and epmc_result.data:
+            for p in epmc_result.data:
                 if p.get("title"):
-                    add("Semantic Scholar", p["title"], (p.get("abstract") or "")[:300])
+                    add("Europe PMC", p["title"], (p.get("abstract") or "")[:300])
+
+        if len(evidence) < 2:
+            pm_result = await self._pubmed().run(query=queries[0], limit=4)
+            if pm_result.success and pm_result.data:
+                for p in pm_result.data:
+                    if p.get("title"):
+                        add("PubMed", p["title"], (p.get("abstract") or "")[:300])
 
         # 2. Academic providers (OpenAlex/Crossref/arXiv) on topic + claim queries
         if len(evidence) < 2:
@@ -245,6 +275,23 @@ class ClaimVerifierAgent(BaseAgent):
             except Exception as e:
                 self.logger.debug(f"Academic evidence search failed: {e}")
 
+        # 3. Wikipedia encyclopedia evidence on the claim's key terms
+        if len(evidence) < 2:
+            wiki_result = await self._wiki().run(query=web_query, limit=3)
+            if wiki_result.success and wiki_result.data:
+                for r in wiki_result.data:
+                    add("Wikipedia", r.get("title", ""), r.get("snippet", ""))
+
+        # 4. Wikidata entity facts
+        if len(evidence) < 2:
+            wd_result = await self._wikidata().run(query=web_query, limit=3)
+            if wd_result.success and wd_result.data:
+                for r in wd_result.data:
+                    desc = r.get("description") or r.get("label", "")
+                    if desc:
+                        add("Wikidata", r.get("label", ""), desc)
+
+        # 5. Web search (Tavily, then DuckDuckGo as keyless fallback)
         if len(evidence) < 2:
             tv_result = await self._tavily().run(query=queries[0], max_results=4)
             if tv_result.success and tv_result.data:

agents/custom/research_agent.py

@@ -5,7 +5,7 @@ This agent performs deep literature review for a given topic.
 """
 from typing import Any, Dict
 from agents.base_agent import BaseAgent, AgentContext
-from tools.search_tool import SemanticScholarTool
+from services.paper_recommender import PaperRecommender
 
 SYSTEM = (
     "You are a research synthesis expert. "
@@ -22,7 +22,7 @@ class ResearchAgent(BaseAgent):
 
     def __init__(self):
         super().__init__()
-        self._search_tool = SemanticScholarTool()
+        self._recommender = PaperRecommender()
 
     async def execute(self, ctx: AgentContext) -> Dict[str, Any]:
         # Get topic from keywords in graph
@@ -35,16 +35,19 @@ class ResearchAgent(BaseAgent):
             return {"status": "skipped", "reason": "no keywords"}
 
         topic = " ".join(r["term"] for r in kw_rows[:3])
-        search_result = await self._search_tool.run(query=topic, limit=10)
+        try:
+            papers = await self._recommender.search_web(topic, limit=10)
+        except Exception as e:
+            return {"status": "failed", "error": str(e)}
 
-        if not search_result.success:
-            return {"status": "failed", "error": search_result.error}
+        if not papers:
+            return {"status": "failed", "error": "no results from academic providers"}
 
         papers_text = "\n".join(
-            f"- {p['title']} ({p.get('year', 'N/A')})"
-            for p in search_result.data[:10]
+            f"- {p.get('title', 'Unknown')} ({p.get('year', 'N/A')})"
+            for p in papers[:10]
         )
         prompt = f"Topic: {topic}\n\nRelated papers:\n{papers_text}"
         analysis = await ctx.llm.complete_json(SYSTEM, prompt)
 
-        return {"topic": topic, "papers_found": len(search_result.data), "analysis": analysis}
+        return {"topic": topic, "papers_found": len(papers), "analysis": analysis}

agents/novelty_agent.py

@@ -11,7 +11,7 @@ from typing import Any, Dict, List
 import json
 
 from agents.base_agent import BaseAgent, AgentContext
-from tools.search_tool import SemanticScholarTool
+from services.paper_recommender import PaperRecommender
 
 EXTRACT_SYSTEM = (
     "You are an expert scientific reviewer. Extract the precise problem "
@@ -36,12 +36,12 @@ class NoveltyAgent(BaseAgent):
 
     def __init__(self):
         super().__init__()
-        self._search_tool = None
+        self._recommender = None
 
-    def _get_search_tool(self) -> SemanticScholarTool:
-        if self._search_tool is None:
-            self._search_tool = SemanticScholarTool()
-        return self._search_tool
+    def _get_recommender(self) -> PaperRecommender:
+        if self._recommender is None:
+            self._recommender = PaperRecommender()
+        return self._recommender
 
     async def execute(self, ctx: AgentContext) -> Dict[str, Any]:
         # 1. Paper metadata
@@ -139,17 +139,20 @@ class NoveltyAgent(BaseAgent):
             queries.append(" ".join(kw_terms[:4])[:120])
 
         found: List[Dict] = []
-        tool = self._get_search_tool()
+        recommender = self._get_recommender()
         for q in queries[:2]:
-            result = await tool.run(query=q, limit=4)
-            if result.success and result.data:
-                for p in result.data:
-                    found.append({
-                        "title": p.get("title", ""),
-                        "year": p.get("year"),
-                        "url": p.get("url", ""),
-                        "why_similar": "search hit for the paper's problem area",
-                    })
+            try:
+                results = await recommender.search_web(q, limit=4)
+            except Exception as e:
+                self.logger.debug(f"Similar-work search failed for '{q[:50]}': {e}")
+                results = []
+            for p in results:
+                found.append({
+                    "title": p.get("title", ""),
+                    "year": p.get("year"),
+                    "url": p.get("url", ""),
+                    "why_similar": "search hit for the paper's problem area",
+                })
         return found
 
     async def _assess_novelty(

scripts/generate_eval_pdf.py

@@ -303,7 +303,7 @@ CROSS_PAPER_MD = """
 Architecture and theory-driven papers (gnn_deeper, yolov10) score highest (8.1+).
 Survey papers (kg_embedding) score at the same level when the field is mature.
 Empirical/applied papers (llm_reasoning, federated_chest) score slightly lower (7-8 range) —
-not because the papers are weaker, but because novel empirical methods are not yet indexed in Semantic Scholar.
+not because the papers are weaker, but because novel empirical methods are not yet indexed in the academic search providers.
 
 ### Pattern 2: Counterfactuality
 All 5 papers score very low on counterfactuality (0.00–0.18), which is the correct result.
@@ -324,14 +324,14 @@ for papers that store references differently (inline footnotes vs numbered lists
 | Issue | Papers Affected | Impact |
 |-------|----------------|--------|
 | KBIR incompatible with transformers 5.8 | ALL 5 | 0 keywords → citation gap disabled |
-| Semantic Scholar 429 rate limits | ALL 5 | Reduced verification confidence |
+| Academic search provider rate limits | ALL 5 | Reduced verification confidence |
 | Reference parser bug (0 refs) | 3/5 papers | Citation completeness score misleading |
 | KeyBERT snapshot path error | ALL 5 | No keyword fallback |
 
 ### Recommended Priority Fixes
 1. **KBIR**: Pin transformers==4.44.0 or replace with KeyBERT + cached all-MiniLM-L6-v2
 2. **Reference parser**: Add fallback regex patterns for footnote/inline reference formats
-3. **Semantic Scholar API key**: Register for free key to eliminate 429 rate limits
+3. **Keyless providers (Europe PMC, PubMed, OpenAlex)**: throttled keyless search replaced Semantic Scholar 429s
 4. **KeyBERT cache**: Pre-download all-MiniLM-L6-v2 to avoid snapshot path errors
 """
 

services/paper_recommender.py

@@ -11,7 +11,8 @@ Providers:
   1. OpenAlex   — broad aggregator (publishers, repositories)
   2. Crossref   — publisher metadata (Elsevier, Springer, IEEE, Wiley, ...)
   3. arXiv      — open-access preprint repository (arxiv.org direct links)
-  4. Semantic Scholar — fallback (unauthenticated rate limits are tight)
+  4. Europe PMC — biomedical literature + preprints + patents (keyless)
+  5. PubMed     — MEDLINE abstracts via NCBI E-utilities (keyless)
 """
 import asyncio
 import math
@@ -21,7 +22,7 @@ from xml.etree import ElementTree
 
 import httpx
 
-from tools.search_tool import SemanticScholarTool
+from tools.search_tool import EuropePMCTool, PubMedTool, UnpaywallTool
 from utils.logger import get_logger
 from utils.retry import async_retry
 
@@ -306,16 +307,24 @@ _PROVIDER_SEM = asyncio.Semaphore(2)
 async def _search_all_providers(
     client: httpx.AsyncClient, query: str, limit: int = 10
 ) -> List[Dict]:
-    """Query OpenAlex, Crossref, arXiv sequentially with a small stagger
-    (kind to rate limits), reusing a shared semaphore across callers."""
+    """Query OpenAlex, Crossref, arXiv, Europe PMC, PubMed sequentially with
+    a small stagger (kind to rate limits), reusing a shared semaphore."""
     results: List[Dict] = []
+    epmc = EuropePMCTool()
+    pubmed = PubMedTool()
     async with _PROVIDER_SEM:
-        for i, fn in enumerate((_search_openalex, _search_crossref, _search_arxiv)):
+        for fn in (_search_openalex, _search_crossref, _search_arxiv):
             try:
                 results.extend(await fn(client, query, limit))
             except Exception as e:
                 logger.debug(f"Provider {fn.__name__} failed for '{query[:50]}': {e}")
             await asyncio.sleep(0.25)
+        for tool in (epmc, pubmed):
+            try:
+                results.extend(await tool.search(query, limit))
+            except Exception as e:
+                logger.debug(f"Provider {type(tool).__name__} failed for '{query[:50]}': {e}")
+            await asyncio.sleep(0.25)
     return results
 
 def _reconstruct_openalex_abstract(inverted: Optional[Dict]) -> str:
@@ -410,8 +419,10 @@ def source_for(paper: Dict) -> str:
     url = (paper.get("url") or "").lower()
     if "arxiv.org" in url:
         return "arXiv"
-    if "semanticscholar.org" in url:
-        return "Semantic Scholar"
+    if "europepmc.org" in url or "pmc.ncbi.nlm.nih.gov" in url:
+        return "Europe PMC"
+    if "pubmed.ncbi.nlm.nih.gov" in url:
+        return "PubMed"
     if "openalex.org" in url:
         return "OpenAlex"
     if "crossref.org" in url or "doi.org" in url:
@@ -464,10 +475,11 @@ async def _search_arxiv(client: httpx.AsyncClient, query: str, limit: int = 10)
 
 
 class PaperRecommender:
-    """Web-based paper recommender (OpenAlex + Crossref + arXiv + fallbacks)."""
+    """Web-based paper recommender (OpenAlex + Crossref + arXiv + Europe PMC
+    + PubMed, with Unpaywall open-access enrichment)."""
 
-    def __init__(self, search_tool: Optional[SemanticScholarTool] = None):
-        self._search_tool = search_tool or SemanticScholarTool()
+    def __init__(self):
+        self._unpaywall = UnpaywallTool()
 
     async def recommend(
         self,
@@ -501,16 +513,6 @@ class PaperRecommender:
         except Exception as e:
             logger.warning(f"Paper recommender HTTP error: {e}")
 
-        if not candidates:
-            # Fall back to Semantic Scholar
-            try:
-                for q in queries[:1]:
-                    result = await self._search_tool.run(query=q, limit=10)
-                    if result.success and result.data:
-                        candidates.extend(result.data)
-            except Exception as e:
-                logger.warning(f"Semantic Scholar fallback failed: {e}")
-
         if not candidates:
             return []
 
@@ -518,8 +520,9 @@ class PaperRecommender:
             c["source"] = source_for(c)
 
         # Same paper from multiple providers (e.g. arXiv + OpenAlex copy):
-        # keep the entry with the most direct link (arXiv > DOI > landing page).
-        _SOURCE_PRIORITY = {"arXiv": 0, "Semantic Scholar": 1, "Crossref": 2}
+        # keep the entry with the most direct link (arXiv > Europe PMC >
+        # PubMed > Crossref landing page).
+        _SOURCE_PRIORITY = {"arXiv": 0, "Europe PMC": 1, "PubMed": 2, "Crossref": 3}
         by_title: Dict[str, Dict] = {}
         for c in candidates:
             key = clean_title(c.get("title", "")).lower()
@@ -552,6 +555,17 @@ class PaperRecommender:
                 chosen = {r["title"].lower() for r in recs}
                 recs += [r for r in filled if r["title"].lower() not in chosen]
 
+        # Enrich top recommendations with open-access copies (silent on failure)
+        for rec in recs:
+            if not rec.get("doi"):
+                continue
+            try:
+                result = await self._unpaywall.run(rec["doi"])
+                if result.success and result.data and result.data.get("url"):
+                    rec["oa_url"] = result.data["url"]
+            except Exception as e:
+                logger.debug(f"Unpaywall enrichment failed for {rec['doi']}: {e}")
+
         return recs[:limit]
 
     async def run(self, query: str, limit: int = 5) -> List[Dict]:
@@ -565,8 +579,9 @@ class PaperRecommender:
         keywords: Optional[List[str]] = None,
     ) -> List[Dict]:
         """
-        Raw academic search (OpenAlex + Crossref + arXiv) without ranking:
-        returns candidates labeled with source, for evidence gathering.
+        Raw academic search (OpenAlex + Crossref + arXiv + Europe PMC +
+        PubMed) without ranking: returns candidates labeled with source,
+        for evidence gathering.
         """
         query_terms = extract_query(query, keywords)
         q = " ".join(query_terms[:4]) if query_terms else query.strip()
@@ -586,7 +601,7 @@ class PaperRecommender:
         for c in candidates:
             c["source"] = source_for(c)
 
-        _SOURCE_PRIORITY = {"arXiv": 0, "Semantic Scholar": 1, "Crossref": 2}
+        _SOURCE_PRIORITY = {"arXiv": 0, "Europe PMC": 1, "PubMed": 2, "Crossref": 3}
         by_title: Dict[str, Dict] = {}
         for c in candidates:
             key = clean_title(c.get("title", "")).lower()

tests/test_agents.py

@@ -168,14 +168,12 @@ async def test_novelty_assesses_and_stores(agent_ctx, mock_neo4j, mock_llm):
         },
     ]
     agent = NoveltyAgent()
-    agent._search_tool = type(
-        "FakeTool",
+    agent._recommender = type(
+        "FakeRecommender",
         (),
         {
-            "run": AsyncMock(
-                return_value=type(
-                    "Res", (), {"success": True, "data": [{"title": "Old Work", "year": 2020, "url": "x"}], "error": ""}
-                )()
+            "search_web": AsyncMock(
+                return_value=[{"title": "Old Work", "year": 2020, "url": "x"}]
             )
         },
     )()
@@ -214,12 +212,10 @@ async def test_novelty_survives_llm_and_search_failure(agent_ctx, mock_neo4j, mo
     ]
     mock_llm.complete_json.side_effect = RuntimeError("LLM down")
     agent = NoveltyAgent()
-    agent._search_tool = type(
-        "FakeTool",
+    agent._recommender = type(
+        "FakeRecommender",
         (),
-        {
-            "run": AsyncMock(return_value=type("Res", (), {"success": False, "data": None, "error": "429 rate limit"})())
-        },
+        {"search_web": AsyncMock(return_value=[])},
     )()
     result = await agent.run(agent_ctx)
     assert result.status == AgentStatus.COMPLETED

tests/test_tools.py

@@ -1,65 +1,192 @@
 import pytest
 from unittest.mock import AsyncMock, MagicMock, patch
-from tools.search_tool import SemanticScholarTool
+from tools.search_tool import EuropePMCTool, PubMedTool, UnpaywallTool
+from tools.wikipedia_tool import WikipediaTool, WikidataTool
 from tools.database_tool import Neo4jTool, MongoTool
 
 
+def _client_ctx(responses):
+    """Build a mocked httpx.AsyncClient whose GET returns `responses` in order."""
+    client = MagicMock()
+    ctx = MagicMock()
+    it = iter(responses)
+
+    async def get(*args, **kwargs):
+        return next(it)
+
+    ctx.get = AsyncMock(side_effect=get)
+    client.__aenter__ = AsyncMock(return_value=ctx)
+    client.__aexit__ = AsyncMock(return_value=None)
+    return client
+
+
+def _resp(status=200, json=None, text=""):
+    r = MagicMock()
+    r.status_code = status
+    r.json.return_value = json if json is not None else {}
+    r.text = text
+    r.raise_for_status = MagicMock()
+    if status >= 400:
+        r.raise_for_status.side_effect = RuntimeError(f"HTTP {status}")
+    return r
+
+
 @pytest.mark.asyncio
-async def test_search_tool_returns_papers():
-    tool = SemanticScholarTool(api_key="test")
+async def test_europepmc_tool_returns_papers():
+    tool = EuropePMCTool()
     mock_response = {
-        "data": [
-            {
-                "title": "Test Paper",
-                "authors": [{"name": "Author A"}],
-                "year": 2023,
-                "abstract": "Test abstract",
-                "citationCount": 10,
-                "externalIds": {"DOI": "10.1234/test"},
-                "paperId": "abc123",
-            }
-        ]
+        "resultList": {
+            "result": [
+                {
+                    "title": "A Study on Federated Learning",
+                    "authorString": "Alice A, Bob B",
+                    "pubYear": "2023",
+                    "abstractText": "We study federated learning.",
+                    "citedByCount": 12,
+                    "doi": "10.1234/test",
+                    "pmcid": "PMC1234567",
+                    "id": "PMC1234567",
+                }
+            ]
+        }
     }
-    with patch("httpx.AsyncClient") as mock_client:
-        mock_resp = MagicMock()
-        mock_resp.json.return_value = mock_response
-        mock_resp.raise_for_status = MagicMock()
-        mock_client.return_value.__aenter__ = AsyncMock(return_value=MagicMock(
-            get=AsyncMock(return_value=mock_resp)
-        ))
-        mock_client.return_value.__aexit__ = AsyncMock(return_value=None)
-        result = await tool.run(query="transformer nlp", limit=1)
+    with patch("httpx.AsyncClient", return_value=_client_ctx([_resp(json=mock_response)])):
+        result = await tool.run(query="federated learning", limit=5)
 
     assert result.success
     assert len(result.data) == 1
-    assert result.data[0]["title"] == "Test Paper"
+    assert result.data[0]["title"] == "A Study on Federated Learning"
+    assert result.data[0]["url"] == "https://europepmc.org/article/PMC/PMC1234567"
+    assert result.data[0]["citation_count"] == 12
 
 
 @pytest.mark.asyncio
-async def test_neo4j_tool_query(mock_neo4j):
-    mock_neo4j.run.return_value = [{"n": "value"}]
-    tool = Neo4jTool(neo4j=mock_neo4j)
-    result = await tool.run(query="MATCH (n) RETURN n LIMIT 1")
+async def test_pubmed_tool_returns_papers():
+    tool = PubMedTool()
+    esearch_json = {"esearchresult": {"idlist": ["33000001"]}}
+    efetch_xml = """<?xml version="1.0"?>
+    <PubmedArticleSet>
+      <PubmedArticle>
+        <MedlineCitation>
+          <PMID>33000001</PMID>
+          <Article>
+            <ArticleTitle>Neural <i>networks</i> for medical imaging</ArticleTitle>
+            <Abstract><AbstractText>We train CNNs on scans.</AbstractText></Abstract>
+            <ArticleDate><Year>2021</Year></ArticleDate>
+            <AuthorList><Author><ForeName>Jane</ForeName><LastName>Doe</LastName></Author></AuthorList>
+            <ELocationID EIdType="doi">10.9999/medimg</ELocationID>
+          </Article>
+        </MedlineCitation>
+      </PubmedArticle>
+    </PubmedArticleSet>"""
+    with patch(
+        "httpx.AsyncClient",
+        return_value=_client_ctx([_resp(json=esearch_json), _resp(text=efetch_xml)]),
+    ):
+        result = await tool.run(query="medical imaging", limit=5)
+
     assert result.success
-    assert result.data == [{"n": "value"}]
+    assert len(result.data) == 1
+    assert result.data[0]["title"] == "Neural networks for medical imaging"
+    assert result.data[0]["abstract"] == "We train CNNs on scans."
+    assert result.data[0]["doi"] == "10.9999/medimg"
+    assert result.data[0]["url"].startswith("https://pubmed.ncbi.nlm.nih.gov/")
 
 
 @pytest.mark.asyncio
-async def test_search_tool_serializes_parallel_calls():
-    """Concurrent Semantic Scholar searches must be spaced out (429 flood regression)."""
+async def test_pubmed_tool_no_ids_returns_empty():
+    tool = PubMedTool()
+    with patch(
+        "httpx.AsyncClient",
+        return_value=_client_ctx([_resp(json={"esearchresult": {"idlist": []}})]),
+    ):
+        result = await tool.run(query="nothing found", limit=5)
+    assert result.success
+    assert result.data == []
+
+
+@pytest.mark.asyncio
+async def test_unpaywall_lookup_returns_oa_url():
+    tool = UnpaywallTool()
+    mock_response = {
+        "is_oa": True,
+        "best_oa_location": {"url": "https://oa.example.com/paper.pdf"},
+    }
+    with patch("httpx.AsyncClient", return_value=_client_ctx([_resp(json=mock_response)])):
+        result = await tool.run("10.1234/test")
+    assert result.success
+    assert result.data["is_oa"] is True
+    assert result.data["url"] == "https://oa.example.com/paper.pdf"
+
+
+@pytest.mark.asyncio
+async def test_unpaywall_lookup_not_oa_404():
+    tool = UnpaywallTool()
+    with patch("httpx.AsyncClient", return_value=_client_ctx([_resp(status=404)])):
+        result = await tool.run("10.1234/missing")
+    assert result.success
+    assert result.data["is_oa"] is False
+    assert result.data["url"] == ""
+
+
+@pytest.mark.asyncio
+async def test_wikipedia_tool_returns_snippets():
+    tool = WikipediaTool()
+    search_json = {
+        "query": {
+            "search": [
+                {"title": "Momentum Investing", "snippet": "<span>Momentum</span> investing basics"},
+            ]
+        }
+    }
+    extracts_json = {
+        "query": {
+            "pages": {
+                "1": {"title": "Momentum Investing", "extract": "Momentum investing is a strategy..."}
+            }
+        }
+    }
+    with patch(
+        "httpx.AsyncClient",
+        return_value=_client_ctx([_resp(json=search_json), _resp(json=extracts_json)]),
+    ):
+        result = await tool.run(query="momentum investing", limit=3)
+    assert result.success
+    assert len(result.data) == 1
+    assert result.data[0]["title"] == "Momentum Investing"
+    assert result.data[0]["url"] == "https://en.wikipedia.org/wiki/Momentum_Investing"
+    assert "Momentum investing is a strategy" in result.data[0]["snippet"]
+
+
+@pytest.mark.asyncio
+async def test_wikidata_tool_returns_entities():
+    tool = WikidataTool()
+    mock_response = {
+        "search": [
+            {"id": "Q42", "label": "Douglas Adams", "description": "English writer and humorist"},
+        ]
+    }
+    with patch("httpx.AsyncClient", return_value=_client_ctx([_resp(json=mock_response)])):
+        result = await tool.run(query="douglas adams", limit=3)
+    assert result.success
+    assert result.data[0]["id"] == "Q42"
+    assert result.data[0]["url"] == "https://www.wikidata.org/wiki/Q42"
+
+
+@pytest.mark.asyncio
+async def test_academic_tools_serialize_parallel_calls():
+    """Concurrent keyless academic searches must be spaced out (rate-limit regression)."""
     import asyncio
     import time
     import tools.search_tool as st
 
-    original_interval = st._SS_MIN_INTERVAL
-    original_last = st._ss_last_request_at
-    st._SS_MIN_INTERVAL = 0.2
-    st._ss_last_request_at = 0.0
+    original_interval = st._ACADEMIC_MIN_INTERVAL
+    original_last = st._academic_last_request_at
+    st._ACADEMIC_MIN_INTERVAL = 0.2
+    st._academic_last_request_at = 0.0
     starts = []
 
-    mock_resp = MagicMock()
-    mock_resp.json.return_value = {"data": []}
-    mock_resp.raise_for_status = MagicMock()
+    empty_ok = {"resultList": {"result": []}}
 
     def make_ctx():
         client = MagicMock()
@@ -67,7 +194,10 @@ async def test_search_tool_serializes_parallel_calls():
 
         async def get(*args, **kwargs):
             starts.append(time.monotonic())
-            return mock_resp
+            r = MagicMock()
+            r.json.return_value = empty_ok
+            r.raise_for_status = MagicMock()
+            return r
 
         ctx.get = AsyncMock(side_effect=get)
         client.__aenter__ = AsyncMock(return_value=ctx)
@@ -75,14 +205,23 @@ async def test_search_tool_serializes_parallel_calls():
         return client
 
     try:
-        with patch("httpx.AsyncClient", side_effect=[make_ctx() for _ in range(3)]):
-            tool = SemanticScholarTool(api_key="test")
+        with patch("httpx.AsyncClient", return_value=make_ctx()):
+            tool = EuropePMCTool()
             results = await asyncio.gather(*[tool.run(query="q", limit=5) for _ in range(3)])
     finally:
-        st._SS_MIN_INTERVAL = original_interval
-        st._ss_last_request_at = original_last
+        st._ACADEMIC_MIN_INTERVAL = original_interval
+        st._academic_last_request_at = original_last
 
     assert all(r.success for r in results)
     assert len(starts) == 3
     deltas = [starts[i + 1] - starts[i] for i in range(2)]
     assert all(d >= 0.18 for d in deltas)
+
+
+@pytest.mark.asyncio
+async def test_neo4j_tool_query(mock_neo4j):
+    mock_neo4j.run.return_value = [{"n": "value"}]
+    tool = Neo4jTool(neo4j=mock_neo4j)
+    result = await tool.run(query="MATCH (n) RETURN n LIMIT 1")
+    assert result.success
+    assert result.data == [{"n": "value"}]

tools/__init__.py

@@ -1,3 +1,3 @@
 from tools.base_tool import BaseTool, ToolResult
-from tools.search_tool import SemanticScholarTool
+from tools.search_tool import EuropePMCTool, PubMedTool, UnpaywallTool
 from tools.database_tool import Neo4jTool, MongoTool

tools/ddg_tool.py

@@ -1,6 +1,6 @@
 """
 DuckDuckGo HTML search tool — no-API-key web fallback for claim verification.
-Used when Semantic Scholar (rate-limited) and Tavily (quota) both fail.
+Used when the academic providers and Tavily (quota) both fail.
 """
 from typing import Dict, List
 

tools/search_tool.py

@@ -1,79 +1,234 @@
 """
-Semantic Scholar search tool for citation gap detection.
+Keyless academic search tools (Europe PMC, PubMed, Unpaywall).
+
+Semantic Scholar was removed: its unauthenticated quota is shared per-IP
+and routinely 429s when parallel pipeline agents search together. Every
+tool here needs no API key.
+
+  Europe PMC — life-science literature (papers, preprints, patents)
+  PubMed     — MEDLINE biomedical abstracts (E-utilities, email-tagged)
+  Unpaywall  — open-access copy lookup by DOI (email-tagged)
 """
 import asyncio
 import os
 import time
 from typing import Dict, List, Optional
+from xml.etree import ElementTree
+
 import httpx
+
 from tools.base_tool import BaseTool, ToolResult
 from utils.logger import get_logger
 from utils.retry import async_retry
 
 logger = get_logger("search_tool")
 
-SS_BASE = "https://api.semanticscholar.org/graph/v1"
-SS_FIELDS = "title,authors,year,abstract,citationCount,externalIds,url"
+EUROPE_PMC_BASE = "https://www.ebi.ac.uk/europepmc/webservices/rest"
+PUBMED_EUTILS = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
+UNPAYWALL_BASE = "https://api.unpaywall.org/v2"
+
+# Public APIs want an email + tool name for fair-use tracking (no key).
+CONTACT_EMAIL = os.getenv("PUBMED_EMAIL", "citationedge@app.local")
 
-# Semantic Scholar's unauthenticated quota (~100 requests / 5 min / IP) is
-# shared process-wide AND with other tenants on the host egress IP. Multiple
-# pipeline agents run in parallel, so every request goes through a global
-# throttle to avoid self-inflicted 429 floods.
-_SS_MIN_INTERVAL = 1.5
-_ss_rate_lock = asyncio.Lock()
-_ss_last_request_at = 0.0
+# Europe PMC and PubMed are burst-sensitive (1-3 req/s without keys), and
+# multiple pipeline agents search in parallel — serialize all calls through
+# a process-wide throttle.
+_ACADEMIC_MIN_INTERVAL = 1.2
+_academic_rate_lock = asyncio.Lock()
+_academic_last_request_at = 0.0
 
 
-async def _throttle_semantic_scholar() -> None:
-    global _ss_last_request_at
-    async with _ss_rate_lock:
+async def _throttle_academic() -> None:
+    global _academic_last_request_at
+    async with _academic_rate_lock:
         now = time.monotonic()
-        wait = _SS_MIN_INTERVAL - (now - _ss_last_request_at)
+        wait = _ACADEMIC_MIN_INTERVAL - (now - _academic_last_request_at)
         if wait > 0:
             await asyncio.sleep(wait)
-        _ss_last_request_at = time.monotonic()
+        _academic_last_request_at = time.monotonic()
 
 
-class SemanticScholarTool(BaseTool):
-    name = "semantic_scholar_search"
-    description = "Search Semantic Scholar for research papers by keyword or title."
+class EuropePMCTool(BaseTool):
+    name = "europepmc_search"
+    description = "Search Europe PMC (biomedical literature, preprints, patents) by keyword or title."
+
+    async def search(self, query: str, limit: int = 5) -> List[Dict]:
+        return await self._fetch(query, min(limit, 25))
+
+    @async_retry(max_attempts=3, delay=1.5)
+    async def _fetch(self, query: str, limit: int) -> List[Dict]:
+        await _throttle_academic()
+        params = {
+            "query": query,
+            "format": "json",
+            "pageSize": limit,
+            "resultType": "core",
+        }
+        async with httpx.AsyncClient(timeout=30) as client:
+            resp = await client.get(f"{EUROPE_PMC_BASE}/search", params=params)
+            resp.raise_for_status()
+            data = resp.json()
 
-    def __init__(self, api_key: Optional[str] = None):
-        self.api_key = api_key or os.getenv("SEMANTIC_SCHOLAR_API_KEY", "")
-        self._headers = {"x-api-key": self.api_key} if self.api_key else {}
+        papers: List[Dict] = []
+        results = ((data.get("resultList") or {}).get("result") or []) or []
+        for r in results:
+            title = (r.get("title") or "").strip()
+            if not title:
+                continue
+            pmcid = r.get("pmcid") or ""
+            doi = r.get("doi") or ""
+            url = (
+                f"https://europepmc.org/article/PMC/{pmcid}"
+                if pmcid else f"https://doi.org/{doi}" if doi else ""
+            )
+            papers.append({
+                "title": title,
+                "authors": [
+                    a.strip() for a in (r.get("authorString") or "").split(",") if a.strip()
+                ][:5],
+                "year": r.get("pubYear"),
+                "abstract": r.get("abstractText") or "",
+                "citation_count": int(r.get("citedByCount") or 0),
+                "doi": doi,
+                "paper_id": r.get("pmcid") or r.get("id") or "",
+                "url": url,
+                "source": "Europe PMC",
+            })
+        return papers
 
-    async def run(self, query: str, limit: int = 10) -> ToolResult:
+    async def run(self, query: str, limit: int = 5) -> ToolResult:
         try:
-            results = await self._search(query, limit)
-            return self._ok(results)
+            return self._ok(await self.search(query, limit))
         except Exception as e:
-            logger.error(f"Semantic Scholar search failed: {e}")
+            logger.error(f"Europe PMC search failed: {e}")
             return self._err(str(e))
 
-    @async_retry(max_attempts=4, delay=2.0, backoff=2.5)
-    async def _search(self, query: str, limit: int) -> List[Dict]:
-        await _throttle_semantic_scholar()
-        async with httpx.AsyncClient(headers=self._headers, timeout=30) as client:
+
+class PubMedTool(BaseTool):
+    name = "pubmed_search"
+    description = "Search PubMed (MEDLINE biomedical abstracts) by keyword or title."
+
+    async def search(self, query: str, limit: int = 5) -> List[Dict]:
+        return await self._fetch(query, min(limit, 10))
+
+    @async_retry(max_attempts=3, delay=1.5)
+    async def _fetch(self, query: str, limit: int) -> List[Dict]:
+        async with httpx.AsyncClient(timeout=30) as client:
+            await _throttle_academic()
+            esearch = await client.get(
+                f"{PUBMED_EUTILS}/esearch.fcgi",
+                params={
+                    "db": "pubmed", "term": query, "retmode": "json",
+                    "retmax": limit, "tool": "citationedge", "email": CONTACT_EMAIL,
+                },
+            )
+            esearch.raise_for_status()
+            ids = (esearch.json().get("esearchresult") or {}).get("idlist") or []
+            if not ids:
+                return []
+
+            await _throttle_academic()
+            efetch = await client.get(
+                f"{PUBMED_EUTILS}/efetch.fcgi",
+                params={
+                    "db": "pubmed", "id": ",".join(ids),
+                    "rettype": "abstract", "retmode": "xml",
+                    "tool": "citationedge", "email": CONTACT_EMAIL,
+                },
+            )
+            efetch.raise_for_status()
+            xml_text = efetch.text
+
+        return self._parse_efetch(xml_text)
+
+    def _parse_efetch(self, xml_text: str) -> List[Dict]:
+        papers: List[Dict] = []
+        try:
+            root = ElementTree.fromstring(xml_text)
+        except ElementTree.ParseError as e:
+            logger.warning(f"PubMed efetch XML parse failed: {e}")
+            return []
+        for art in root.findall(".//PubmedArticle"):
+            medline = art.find("MedlineCitation")
+            if medline is None:
+                continue
+            title_node = medline.find("Article/ArticleTitle")
+            title = "".join(title_node.itertext()).strip() if title_node is not None else ""
+            if not title:
+                continue
+            pmid = (medline.findtext("PMID") or "").strip()
+            doi = ""
+            doi_node = medline.find("Article/ELocationID[@EIdType='doi']")
+            if doi_node is not None and doi_node.text:
+                doi = doi_node.text.strip()
+            if not doi:
+                doi_node = art.find("PubmedData/ArticleIdList/ArticleId[@IdType='doi']")
+                if doi_node is not None and doi_node.text:
+                    doi = doi_node.text.strip()
+
+            abstract = " ".join(
+                "".join(t.itertext()) for t in medline.findall("Article/Abstract/AbstractText")
+            ).strip()
+            year = (
+                medline.findtext("Article/ArticleDate/Year")
+                or medline.findtext("Article/JournalIssue/PubDate/Year")
+                or ""
+            )
+            authors = [
+                f"{a.findtext('ForeName', '')} {a.findtext('LastName', '')}".strip()
+                for a in medline.findall("Article/AuthorList/Author")
+                if a.findtext("LastName", "")
+            ]
+            authors = [a for a in authors if a][:5]
+
+            papers.append({
+                "title": title,
+                "authors": authors,
+                "year": int(year) if year and year.isdigit() else None,
+                "abstract": abstract,
+                "citation_count": 0,  # PubMed does not expose cited-by here
+                "doi": doi,
+                "paper_id": pmid,
+                "url": f"https://pubmed.ncbi.nlm.nih.gov/{pmid}/" if pmid else "",
+                "source": "PubMed",
+            })
+        return papers
+
+    async def run(self, query: str, limit: int = 5) -> ToolResult:
+        try:
+            return self._ok(await self.search(query, limit))
+        except Exception as e:
+            logger.error(f"PubMed search failed: {e}")
+            return self._err(str(e))
+
+
+class UnpaywallTool(BaseTool):
+    name = "unpaywall_lookup"
+    description = "Look up the open-access copy of a paper by DOI (Unpaywall)."
+
+    @async_retry(max_attempts=2, delay=1.0)
+    async def _lookup(self, doi: str) -> Dict:
+        async with httpx.AsyncClient(timeout=30) as client:
             resp = await client.get(
-                f"{SS_BASE}/paper/search",
-                params={"query": query, "limit": limit, "fields": SS_FIELDS},
+                f"{UNPAYWALL_BASE}/{doi}", params={"email": CONTACT_EMAIL}
             )
+            if resp.status_code == 404:
+                return {"doi": doi, "is_oa": False, "url": ""}
             resp.raise_for_status()
             data = resp.json()
-            papers = data.get("data", [])
-            logger.debug(f"Semantic Scholar: {len(papers)} results for '{query}'")
-            return [self._normalize(p) for p in papers]
-
-    def _normalize(self, paper: Dict) -> Dict:
-        authors = [a.get("name", "") for a in paper.get("authors", [])]
-        doi = paper.get("externalIds", {}).get("DOI", "")
+        loc = data.get("best_oa_location") or {}
         return {
-            "title": paper.get("title", ""),
-            "authors": authors,
-            "year": paper.get("year"),
-            "abstract": paper.get("abstract", ""),
-            "citation_count": paper.get("citationCount", 0),
             "doi": doi,
-            "paper_id": paper.get("paperId", ""),
-            "url": paper.get("url", ""),
+            "is_oa": bool(data.get("is_oa")),
+            "url": loc.get("url") or loc.get("url_for_pdf") or "",
         }
+
+    async def run(self, doi: str) -> ToolResult:
+        doi = (doi or "").strip()
+        if not doi:
+            return self._err("DOI required")
+        try:
+            return self._ok(await self._lookup(doi))
+        except Exception as e:
+            logger.error(f"Unpaywall lookup failed for {doi}: {e}")
+            return self._err(str(e))

tools/tavily_tool.py

@@ -1,6 +1,6 @@
 """
 Tavily Search tool — web search fallback for claim verification.
-Used when Semantic Scholar returns no results for a specific claim.
+Used when the keyless academic providers return no results for a specific claim.
 """
 import os
 from typing import Dict, List, Optional

tools/wikipedia_tool.py

@@ -0,0 +1,151 @@
+"""
+Keyless Wikipedia + Wikidata evidence tools for claim verification.
+
+  Wikipedia — encyclopedia search + lead-section extracts
+  Wikidata   — entity search (people, places, concepts) with descriptions
+"""
+import asyncio
+import re
+import time
+from typing import Dict, List
+
+import httpx
+
+from tools.base_tool import BaseTool, ToolResult
+from utils.logger import get_logger
+from utils.retry import async_retry
+
+logger = get_logger("wikipedia_tool")
+
+WIKIPEDIA_API = "https://en.wikipedia.org/w/api.php"
+WIKIDATA_API = "https://www.wikidata.org/w/api.php"
+
+# Wikimedia policy requires a descriptive User-Agent (contact info included);
+# generic client UAs (e.g. python-httpx) are rejected with 403.
+WIKI_HEADERS = {
+    "User-Agent": "CitationEdge/1.0 (citationedge@app.local; academic citation analysis)"
+}
+
+_TAG_RE = re.compile(r"<[^>]+>")
+
+_WIKI_MIN_INTERVAL = 1.0
+_wiki_rate_lock = asyncio.Lock()
+_wiki_last_request_at = 0.0
+
+
+async def _throttle_wiki() -> None:
+    global _wiki_last_request_at
+    async with _wiki_rate_lock:
+        now = time.monotonic()
+        wait = _WIKI_MIN_INTERVAL - (now - _wiki_last_request_at)
+        if wait > 0:
+            await asyncio.sleep(wait)
+        _wiki_last_request_at = time.monotonic()
+
+
+def _strip_html(text: str) -> str:
+    return _TAG_RE.sub("", text or "").strip()
+
+
+class WikipediaTool(BaseTool):
+    name = "wikipedia_search"
+    description = "Search Wikipedia for encyclopedia evidence on a topic."
+
+    async def search(self, query: str, limit: int = 3) -> List[Dict]:
+        return await self._fetch(query, min(limit, 10))
+
+    @async_retry(max_attempts=3, delay=1.5)
+    async def _fetch(self, query: str, limit: int) -> List[Dict]:
+        async with httpx.AsyncClient(timeout=30, headers=WIKI_HEADERS) as client:
+            await _throttle_wiki()
+            search = await client.get(
+                WIKIPEDIA_API,
+                params={
+                    "action": "query", "list": "search", "srsearch": query,
+                    "srlimit": limit, "format": "json",
+                },
+            )
+            search.raise_for_status()
+            hits = (search.json().get("query") or {}).get("search") or []
+            titles = [h.get("title") for h in hits if h.get("title")]
+            if not titles:
+                return []
+
+            await _throttle_wiki()
+            extracts = await client.get(
+                WIKIPEDIA_API,
+                params={
+                    "action": "query", "prop": "extracts", "exintro": 1,
+                    "explaintext": 1, "titles": "|".join(titles[:10]),
+                    "format": "json",
+                },
+            )
+            extracts.raise_for_status()
+            pages = (extracts.json().get("query") or {}).get("pages") or {}
+
+        by_title = {
+            (p.get("title") or ""): p
+            for p in pages.values() if isinstance(p, dict)
+        }
+        results: List[Dict] = []
+        for hit in hits:
+            title = hit.get("title") or ""
+            if not title:
+                continue
+            page = by_title.get(title) or {}
+            snippet = (
+                (page.get("extract") or "").strip()
+                or _strip_html(hit.get("snippet") or "")
+            )
+            results.append({
+                "title": title,
+                "url": f"https://en.wikipedia.org/wiki/{title.replace(' ', '_')}",
+                "snippet": snippet[:400],
+                "source": "Wikipedia",
+            })
+        return results
+
+    async def run(self, query: str, limit: int = 3) -> ToolResult:
+        try:
+            return self._ok(await self.search(query, limit))
+        except Exception as e:
+            logger.error(f"Wikipedia search failed: {e}")
+            return self._err(str(e))
+
+
+class WikidataTool(BaseTool):
+    name = "wikidata_lookup"
+    description = "Search Wikidata for entity facts (people, places, concepts)."
+
+    @async_retry(max_attempts=3, delay=1.5)
+    async def _fetch(self, query: str, limit: int) -> List[Dict]:
+        await _throttle_wiki()
+        params = {
+            "action": "wbsearchentities", "search": query, "language": "en",
+            "format": "json", "limit": limit,
+        }
+        async with httpx.AsyncClient(timeout=30, headers=WIKI_HEADERS) as client:
+            resp = await client.get(WIKIDATA_API, params=params)
+            resp.raise_for_status()
+            hits = resp.json().get("search") or []
+
+        results: List[Dict] = []
+        for h in hits:
+            qid = h.get("id") or ""
+            if not qid:
+                continue
+            results.append({
+                "id": qid,
+                "label": h.get("label") or qid,
+                "description": h.get("description") or "",
+                "url": f"https://www.wikidata.org/wiki/{qid}",
+                "source": "Wikidata",
+            })
+        return results
+
+    async def run(self, query: str, limit: int = 3) -> ToolResult:
+        try:
+            return self._ok(await self._fetch(query, min(limit, 10)))
+        except Exception as e:
+            logger.error(f"Wikidata search failed: {e}")
+            return self._err(str(e))