@wentorai/research-plugins 1.4.0 → 1.4.3

package/skills/literature/discovery/semantic-paper-radar/SKILL.md

@@ -31,16 +31,16 @@ Key components:
 - **Vector database**: Stores and indexes embeddings for fast similarity search. Options include ChromaDB (local), Qdrant, Pinecone, or Weaviate.
 - **Similarity metric**: Cosine similarity is standard for comparing text embeddings.
 
-### Using Semantic Scholar's Embedding Search
+### Using OpenAlex's Search API
 
-Semantic Scholar provides pre-computed SPECTER embeddings for millions of papers. You can use their search API for semantic queries:
+OpenAlex indexes 250M+ works and supports search queries across all disciplines:
 
 ```bash
-# Semantic search via the Semantic Scholar API
-curl "https://api.semanticscholar.org/graph/v1/paper/search?query=attention+mechanisms+for+graph+neural+networks&fields=title,abstract,year,citationCount&limit=20"
+# Search works via the OpenAlex API
+curl "https://api.openalex.org/works?search=attention+mechanisms+for+graph+neural+networks&per_page=20"
 ```
 
-The search endpoint uses semantic matching, not just keyword matching. A query like "methods for handling missing values in longitudinal studies" will find papers about imputation techniques, dropout analysis, and panel data methods even if they do not use the phrase "missing values."
+The search endpoint uses relevance-ranked matching. Combine with concept filters and citation data for more targeted discovery. For true semantic matching, build a local embedding index (see below).
 
 ### Building a Personal Semantic Index
 
@@ -84,7 +84,7 @@ This local index lets you search across all papers you have collected using natu
 Use semantic search to expand your awareness beyond your current reading:
 
 1. **Seed**: Take the abstract of your current paper (or a paragraph describing your research question).
-2. **Search**: Run it as a semantic query against a large corpus (Semantic Scholar, OpenAlex, or your local index).
+2. **Search**: Run it as a semantic query against a large corpus (OpenAlex, CrossRef, or your local index).
 3. **Filter**: Remove papers you have already read. Sort by a combination of semantic similarity and recency.
 4. **Cluster**: Group the top 50 results into thematic clusters using k-means or HDBSCAN on their embeddings.
 5. **Explore clusters**: Each cluster represents a related subtopic. Read the most-cited paper in each cluster to understand the connection to your work.
@@ -103,7 +103,7 @@ Semantic search excels at finding papers from other fields that address similar
 Set up periodic semantic searches to detect new papers in your area:
 
 1. Define 3-5 "concept vectors" by encoding descriptions of your core research interests.
-2. Weekly, search against newly published papers (last 7 days) from arXiv or Semantic Scholar.
+2. Weekly, search against newly published papers (last 7 days) from arXiv or OpenAlex.
 3. Rank new papers by maximum similarity to any of your concept vectors.
 4. Papers above your similarity threshold enter your reading queue automatically.
 
@@ -137,7 +137,7 @@ Compare your research question against the semantic landscape of existing work.
 
 ## References
 
-- Semantic Scholar API: https://api.semanticscholar.org
+- OpenAlex API: https://api.openalex.org
 - SPECTER2 model: https://huggingface.co/allenai/specter2
 - ChromaDB: https://www.trychroma.com
 - ResearchGPT: https://github.com/mukulpatnaik/researchgpt

package/skills/literature/discovery/semantic-scholar-recs-guide/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: semantic-scholar-recs-guide
-description: "Using Semantic Scholar recommendations API for paper discovery"
+description: "Paper discovery via recommendation APIs (OpenAlex, CrossRef citation networks)"
 metadata:
   openclaw:
     emoji: "🤖"
@@ -10,70 +10,72 @@ metadata:
     source: "wentor-research-plugins"
 ---
 
-# Semantic Scholar Recommendations Guide
+# Paper Discovery via OpenAlex & CrossRef
 
-Leverage the Semantic Scholar (S2) API to discover related papers, traverse citation networks, and build comprehensive reading lists programmatically.
+Leverage the OpenAlex and CrossRef APIs to discover related papers, traverse citation networks, and build comprehensive reading lists programmatically.
 
 ## Overview
 
-Semantic Scholar indexes over 200 million academic papers and provides a free, rate-limited API that supports:
+OpenAlex indexes over 250 million academic works and provides a free, no-key-required API that supports:
 
-- Paper search by title, keyword, or DOI
-- Recommendations based on positive and negative seed papers
+- Work search by title, keyword, or DOI
 - Citation and reference graph traversal
 - Author profiles and publication histories
-- Bulk data access for large-scale analyses
+- Concept-based discovery across disciplines
+- Institutional and venue filtering
 
-Base URL: `https://api.semanticscholar.org/graph/v1`
-Recommendations endpoint: `https://api.semanticscholar.org/recommendations/v1`
+Base URL: `https://api.openalex.org`
+CrossRef URL: `https://api.crossref.org`
 
-## Getting Recommendations from Seed Papers
+## Finding Related Papers
 
-The recommendations endpoint accepts a list of positive (and optionally negative) paper IDs and returns related papers ranked by relevance.
+Use OpenAlex's concept graph and citation data to discover related work from seed papers.
 
-### Single-Paper Recommendations
+### Concept-Based Discovery
 
 ```python
 import requests
 
-PAPER_ID = "649def34f8be52c8b66281af98ae884c09aef38b"  # SHA or S2 ID
+HEADERS = {"User-Agent": "ResearchPlugins/1.0 (https://wentor.ai)"}
+WORK_ID = "W2741809807"  # OpenAlex work ID
 
+# Get the seed paper's concepts
 response = requests.get(
-    f"https://api.semanticscholar.org/recommendations/v1/papers/forpaper/{PAPER_ID}",
-    params={
-        "fields": "title,authors,year,citationCount,abstract,externalIds",
-        "limit": 20
-    },
-    headers={"x-api-key": "YOUR_API_KEY"}  # optional, increases rate limit
+    f"https://api.openalex.org/works/{WORK_ID}",
+    headers=HEADERS
 )
-
-for paper in response.json()["recommendedPapers"]:
-    print(f"[{paper['year']}] {paper['title']} (citations: {paper['citationCount']})")
+paper = response.json()
+concepts = [c["id"] for c in paper.get("concepts", [])[:3]]
+
+# Find works sharing the same concepts, sorted by citations
+for concept_id in concepts:
+    related = requests.get(
+        "https://api.openalex.org/works",
+        params={"filter": f"concepts.id:{concept_id}", "sort": "cited_by_count:desc", "per_page": 10},
+        headers=HEADERS
+    )
+    for w in related.json().get("results", []):
+        print(f"[{w.get('publication_year')}] {w.get('title')} (citations: {w.get('cited_by_count')})")
 ```
 
-### Multi-Paper Recommendations (Positive + Negative Seeds)
+### CrossRef Subject-Based Discovery
 
 ```python
 import requests
 
-payload = {
-    "positivePaperIds": [
-        "649def34f8be52c8b66281af98ae884c09aef38b",
-        "ARXIV:2005.14165"  # can use arXiv ID prefix
-    ],
-    "negativePaperIds": [
-        "ArXiv:1706.03762"  # exclude attention-is-all-you-need style papers
-    ]
-}
-
-response = requests.post(
-    "https://api.semanticscholar.org/recommendations/v1/papers/",
-    json=payload,
-    params={"fields": "title,year,citationCount,url,abstract", "limit": 30}
-)
-
-results = response.json()["recommendedPapers"]
-print(f"Found {len(results)} recommended papers")
+def search_crossref(query, limit=10, sort="is-referenced-by-count"):
+    """Search CrossRef for papers sorted by citation count."""
+    resp = requests.get(
+        "https://api.crossref.org/works",
+        params={"query": query, "rows": limit, "sort": sort, "order": "desc"},
+        headers={"User-Agent": "ResearchPlugins/1.0 (https://wentor.ai; mailto:dev@wentor.ai)"}
+    )
+    return resp.json().get("message", {}).get("items", [])
+
+results = search_crossref("transformer attention mechanism")
+for w in results:
+    title = w.get("title", [""])[0] if w.get("title") else ""
+    print(f"  {title} — Cited by: {w.get('is-referenced-by-count', 0)}")
 ```
 
 ## Citation Network Traversal
@@ -83,48 +85,49 @@ Walk the citation graph to discover foundational and derivative works.
 ### Forward Citations (Who Cited This Paper?)
 
 ```python
-paper_id = "649def34f8be52c8b66281af98ae884c09aef38b"
+work_id = "W2741809807"
 
 response = requests.get(
-    f"https://api.semanticscholar.org/graph/v1/paper/{paper_id}/citations",
+    "https://api.openalex.org/works",
     params={
-        "fields": "title,year,citationCount,authors",
-        "limit": 100,
-        "offset": 0
-    }
+        "filter": f"cites:{work_id}",
+        "sort": "cited_by_count:desc",
+        "per_page": 20
+    },
+    headers=HEADERS
 )
 
-citations = response.json()["data"]
-# Sort by citation count to find most influential derivative works
-citations.sort(key=lambda x: x["citingPaper"]["citationCount"], reverse=True)
-for c in citations[:10]:
-    p = c["citingPaper"]
-    print(f"  [{p['year']}] {p['title']} ({p['citationCount']} cites)")
+for w in response.json().get("results", []):
+    print(f"  [{w.get('publication_year')}] {w.get('title')} ({w.get('cited_by_count')} cites)")
 ```
 
 ### Backward References (What Did This Paper Cite?)
 
 ```python
 response = requests.get(
-    f"https://api.semanticscholar.org/graph/v1/paper/{paper_id}/references",
-    params={"fields": "title,year,citationCount,authors", "limit": 100}
+    f"https://api.openalex.org/works/{work_id}",
+    headers=HEADERS
 )
+paper = response.json()
+ref_ids = paper.get("referenced_works", [])
 
-refs = response.json()["data"]
-refs.sort(key=lambda x: x["citedPaper"]["citationCount"], reverse=True)
+# Fetch details for referenced works
+for ref_id in ref_ids[:20]:
+    ref = requests.get(f"https://api.openalex.org/works/{ref_id.split('/')[-1]}", headers=HEADERS).json()
+    print(f"  [{ref.get('publication_year')}] {ref.get('title')} ({ref.get('cited_by_count')} cites)")
 ```
 
 ## Building a Reading List Pipeline
 
-Combine search, recommendations, and citation traversal into a discovery pipeline:
+Combine search, concept discovery, and citation traversal into a discovery pipeline:
 
 | Step | Method | Purpose |
 |------|--------|---------|
 | 1. Seed selection | Manual or keyword search | Identify 3-5 highly relevant papers |
-| 2. Expand via recs | Multi-paper recommendations | Find thematically related work |
-| 3. Forward citation | Citations endpoint | Find recent derivative works |
-| 4. Backward citation | References endpoint | Find foundational papers |
-| 5. Deduplicate | S2 paper ID matching | Remove duplicates across steps |
+| 2. Expand via concepts | OpenAlex concept graph | Find thematically related work |
+| 3. Forward citation | OpenAlex cites filter | Find recent derivative works |
+| 4. Backward citation | referenced_works field | Find foundational papers |
+| 5. Deduplicate | OpenAlex work ID matching | Remove duplicates across steps |
 | 6. Rank & filter | Sort by year, citations, relevance | Prioritize reading order |
 
 ```python
@@ -133,32 +136,46 @@ def build_reading_list(seed_ids, max_papers=50):
     seen = set()
     candidates = []
 
-    # Step 1: Get recommendations
-    recs = get_recommendations(seed_ids)
-    for paper in recs:
-        if paper["paperId"] not in seen:
-            seen.add(paper["paperId"])
-            candidates.append(paper)
-
-    # Step 2: Get citations of seed papers
-    for sid in seed_ids:
-        cites = get_citations(sid, limit=50)
-        for c in cites:
-            pid = c["citingPaper"]["paperId"]
-            if pid not in seen:
-                seen.add(pid)
-                candidates.append(c["citingPaper"])
-
-    # Step 3: Rank by citation count and recency
-    candidates.sort(key=lambda p: (p.get("year", 0), p.get("citationCount", 0)), reverse=True)
+    for seed_id in seed_ids:
+        # Get concepts from seed paper
+        paper = requests.get(f"https://api.openalex.org/works/{seed_id}", headers=HEADERS).json()
+        concept_ids = [c["id"] for c in paper.get("concepts", [])[:2]]
+
+        # Find related works via concepts
+        for cid in concept_ids:
+            related = requests.get(
+                "https://api.openalex.org/works",
+                params={"filter": f"concepts.id:{cid}", "sort": "cited_by_count:desc", "per_page": 20},
+                headers=HEADERS
+            ).json().get("results", [])
+            for w in related:
+                wid = w.get("id", "").split("/")[-1]
+                if wid not in seen:
+                    seen.add(wid)
+                    candidates.append(w)
+
+        # Get citing works
+        citing = requests.get(
+            "https://api.openalex.org/works",
+            params={"filter": f"cites:{seed_id}", "sort": "cited_by_count:desc", "per_page": 20},
+            headers=HEADERS
+        ).json().get("results", [])
+        for w in citing:
+            wid = w.get("id", "").split("/")[-1]
+            if wid not in seen:
+                seen.add(wid)
+                candidates.append(w)
+
+    # Rank by citation count and recency
+    candidates.sort(key=lambda p: (p.get("publication_year", 0), p.get("cited_by_count", 0)), reverse=True)
     return candidates[:max_papers]
 ```
 
-## Rate Limits and Best Practices
+## Best Practices
 
-- **Without API key**: 100 requests per 5 minutes
-- **With API key**: 1 request/second sustained (request a key at semanticscholar.org/product/api)
-- Always include only the fields you need to reduce payload size
-- Use `offset` and `limit` for pagination on large result sets
+- OpenAlex is free with no API key required; use a polite `User-Agent` header
+- CrossRef requires a polite pool user agent with contact info for higher rate limits
+- Always include only the fields you need via `select` parameter to reduce payload size
+- Use `page` and `per_page` for pagination on large result sets
 - Cache responses locally to avoid redundant requests
-- Use DOI, arXiv ID, or PubMed ID as paper identifiers for cross-system compatibility (prefix with `DOI:`, `ARXIV:`, or `PMID:`)
+- Use DOI as the universal identifier for cross-system compatibility

package/skills/literature/fulltext/open-access-guide/SKILL.md

@@ -84,7 +84,7 @@ else:
 | SSRN | Preprint server | Social sciences, law, economics | ssrn.com |
 | Zenodo | Repository | All disciplines | zenodo.org |
 | CORE | Aggregator | 300M+ papers from repositories | core.ac.uk |
-| Semantic Scholar | Search + OA links | Cross-disciplinary | semanticscholar.org |
+| OpenAlex | Search + OA links | Cross-disciplinary | openalex.org |
 | BASE (Bielefeld) | Aggregator | 400M+ documents | base-search.net |
 
 ### Batch OA Lookup

package/skills/literature/fulltext/open-access-mining-guide/SKILL.md

@@ -93,11 +93,11 @@ Unpaywall / OpenAlex:
   - Use: Find OA versions of any DOI
   - Best for: Locating freely available versions of papers
 
-Semantic Scholar:
-  - Coverage: 200M+ papers, abstracts + some full text
-  - Access: Free API, bulk datasets
-  - Features: TLDR summaries, citation intents, S2ORC corpus
-  - Best for: NLP research on scientific text
+OpenAlex:
+  - Coverage: 250M+ works, all disciplines
+  - Access: Free API, no key required
+  - Features: Concepts, citation counts, author profiles, institution data
+  - Best for: Cross-disciplinary metadata and OA discovery
 ```
 
 ## Full-Text Retrieval and Parsing

package/skills/literature/metadata/citation-network-guide/SKILL.md

@@ -49,7 +49,7 @@ Whether you are conducting a systematic literature review, mapping a new researc
 
 | Source | Coverage | API | Cost |
 |--------|----------|-----|------|
-| Semantic Scholar | 200M+ papers, CS/biomed focus | REST API, free | Free (rate limited) |
+| OpenAlex | 250M+ works, all disciplines | REST API, free | Free (no key required) |
 | OpenAlex | 250M+ works, all disciplines | REST API, free | Free |
 | Crossref | 140M+ DOIs | REST API | Free |
 | Web of Science | Curated, multi-disciplinary | Institutional | Licensed |
@@ -219,7 +219,7 @@ Traditional citations take years to accumulate. Altmetrics capture immediate att
 
 ## Best Practices
 
-- **Combine multiple data sources.** No single database has complete coverage. Merge OpenAlex and Semantic Scholar for best results.
+- **Combine multiple data sources.** No single database has complete coverage. Merge OpenAlex and CrossRef for best results.
 - **Normalize by field and age.** A 2024 paper in biology and a 2024 paper in mathematics have very different citation rate baselines.
 - **Use relative indicators.** Field-Weighted Citation Impact (FWCI) accounts for disciplinary differences.
 - **Do not equate citations with quality.** Retracted papers sometimes have high citation counts. Controversial papers accumulate criticism citations.
@@ -229,7 +229,7 @@ Traditional citations take years to accumulate. Altmetrics capture immediate att
 ## References
 
 - [OpenAlex API](https://docs.openalex.org/) -- Free, open bibliographic data
-- [Semantic Scholar API](https://api.semanticscholar.org/) -- AI-powered paper data
+- [CrossRef API](https://api.crossref.org/) -- DOI resolution and metadata
 - [VOSviewer](https://www.vosviewer.com/) -- Bibliometric visualization tool
 - [bibliometrix R package](https://www.bibliometrix.org/) -- Comprehensive bibliometric analysis
 - [Altmetric](https://www.altmetric.com/) -- Alternative impact metrics

package/skills/literature/metadata/h-index-guide/SKILL.md

@@ -115,33 +115,6 @@ for source in results:
 
 Google Scholar profiles automatically display h-index and i10-index. No calculation needed, but coverage is the broadest (includes non-peer-reviewed sources).
 
-### From Semantic Scholar API
-
-```python
-def get_author_h_index(author_name):
-    """Calculate h-index for an author using Semantic Scholar."""
-    # Search for author
-    search_resp = requests.get(
-        "https://api.semanticscholar.org/graph/v1/author/search",
-        params={"query": author_name, "limit": 1}
-    )
-    authors = search_resp.json().get("data", [])
-    if not authors:
-        return None
-
-    author_id = authors[0]["authorId"]
-
-    # Get all papers with citation counts
-    papers_resp = requests.get(
-        f"https://api.semanticscholar.org/graph/v1/author/{author_id}/papers",
-        params={"fields": "citationCount", "limit": 1000}
-    )
-    papers = papers_resp.json().get("data", [])
-    citation_counts = [p.get("citationCount", 0) for p in papers]
-
-    return calculate_h_index(citation_counts)
-```
-
 ### From OpenAlex
 
 ```python

package/skills/literature/search/SKILL.md

@@ -36,7 +36,7 @@ Select the skill matching the user's need, then `read` its SKILL.md.
 | [plos-open-access-api](./plos-open-access-api/SKILL.md) | Search PLOS open access journals with full-text Solr-powered API |
 | [pubmed-api](./pubmed-api/SKILL.md) | Search biomedical literature and retrieve records via PubMed E-utilities |
 | [scielo-api](./scielo-api/SKILL.md) | Access Latin American and developing world research via SciELO API |
-| [semantic-scholar-api](./semantic-scholar-api/SKILL.md) | Search papers and analyze citation graphs via Semantic Scholar |
+| [semantic-scholar-api](./semantic-scholar-api/SKILL.md) | Search papers and analyze citation graphs via OpenAlex and CrossRef APIs |
 | [share-research-api](./share-research-api/SKILL.md) | Discover open access research outputs via the SHARE notification API |
 | [systematic-search-strategy](./systematic-search-strategy/SKILL.md) | Construct rigorous systematic search strategies for literature reviews |
 | [worldcat-search-api](./worldcat-search-api/SKILL.md) | Search the world's largest library catalog via OCLC WorldCat API |

package/skills/literature/search/citation-chaining-guide/SKILL.md

@@ -40,24 +40,30 @@ Examine the reference list of each seed paper and identify which cited works are
 ```python
 import requests
 
-def get_references(paper_id, limit=100):
-    """Get all references of a paper via Semantic Scholar."""
-    url = f"https://api.semanticscholar.org/graph/v1/paper/{paper_id}/references"
-    response = requests.get(url, params={
-        "fields": "title,year,citationCount,externalIds,abstract",
-        "limit": limit
-    })
-    refs = response.json().get("data", [])
-    return [r["citedPaper"] for r in refs if r["citedPaper"].get("title")]
+HEADERS = {"User-Agent": "ResearchPlugins/1.0 (https://wentor.ai)"}
+
+def get_references(work_id):
+    """Get all references of a paper via OpenAlex."""
+    url = f"https://api.openalex.org/works/{work_id}"
+    response = requests.get(url, headers=HEADERS)
+    paper = response.json()
+    ref_ids = paper.get("referenced_works", [])
+
+    references = []
+    for ref_id in ref_ids:
+        ref = requests.get(f"https://api.openalex.org/works/{ref_id.split('/')[-1]}", headers=HEADERS).json()
+        if ref.get("title"):
+            references.append(ref)
+    return references
 
 # Get references of a seed paper
-seed_doi = "DOI:10.1038/s41586-021-03819-2"
-references = get_references(seed_doi)
+seed_id = "W2741809807"
+references = get_references(seed_id)
 
 # Sort by citation count to find the most influential foundations
-references.sort(key=lambda p: p.get("citationCount", 0), reverse=True)
+references.sort(key=lambda p: p.get("cited_by_count", 0), reverse=True)
 for ref in references[:15]:
-    print(f"[{ref.get('year', '?')}] {ref['title']} ({ref.get('citationCount', 0)} citations)")
+    print(f"[{ref.get('publication_year', '?')}] {ref['title']} ({ref.get('cited_by_count', 0)} citations)")
 ```
 
 ### Step 3: Forward Chaining (Citation Tracking)
@@ -65,28 +71,32 @@ for ref in references[:15]:
 Find all papers that have cited your seed paper.
 
 ```python
-def get_citations(paper_id, limit=200):
-    """Get papers citing a given paper via Semantic Scholar."""
-    url = f"https://api.semanticscholar.org/graph/v1/paper/{paper_id}/citations"
+def get_citations(work_id, limit=200):
+    """Get papers citing a given paper via OpenAlex."""
     all_citations = []
-    offset = 0
-    while offset < limit:
-        response = requests.get(url, params={
-            "fields": "title,year,citationCount,externalIds,abstract",
-            "limit": min(100, limit - offset),
-            "offset": offset
-        })
-        data = response.json().get("data", [])
-        if not data:
+    page = 1
+    while len(all_citations) < limit:
+        response = requests.get(
+            "https://api.openalex.org/works",
+            params={
+                "filter": f"cites:{work_id}",
+                "sort": "cited_by_count:desc",
+                "per_page": min(200, limit - len(all_citations)),
+                "page": page
+            },
+            headers=HEADERS
+        )
+        results = response.json().get("results", [])
+        if not results:
             break
-        all_citations.extend([c["citingPaper"] for c in data if c["citingPaper"].get("title")])
-        offset += len(data)
+        all_citations.extend(results)
+        page += 1
     return all_citations
 
-citations = get_citations(seed_doi)
+citations = get_citations(seed_id)
 # Filter for recent, well-cited papers
-recent_impactful = [c for c in citations if c.get("year", 0) >= 2022 and c.get("citationCount", 0) >= 5]
-recent_impactful.sort(key=lambda p: p.get("citationCount", 0), reverse=True)
+recent_impactful = [c for c in citations if c.get("publication_year", 0) >= 2022 and c.get("cited_by_count", 0) >= 5]
+recent_impactful.sort(key=lambda p: p.get("cited_by_count", 0), reverse=True)
 ```
 
 ### Step 4: Co-Citation and Bibliographic Coupling
@@ -134,7 +144,7 @@ Repeat the process with the most relevant papers discovered in each round:
 | Google Scholar "Cited by" | Forward chaining | Free |
 | Web of Science "Cited References" / "Times Cited" | Both directions | Subscription |
 | Scopus "References" / "Cited by" | Both directions | Subscription |
-| Semantic Scholar API | Programmatic, both directions | Free |
+| OpenAlex API | Programmatic, both directions | Free |
 | Connected Papers (connectedpapers.com) | Visual co-citation graph | Free (limited) |
 | Litmaps (litmaps.com) | Visual citation network | Free tier |
 | CoCites (cocites.com) | Co-citation analysis | Free |
@@ -145,4 +155,4 @@ Repeat the process with the most relevant papers discovered in each round:
 - **Citation bias**: Highly cited papers are not always the best or most relevant. Pay attention to less-cited but methodologically sound papers.
 - **Recency bias**: Forward chaining favors recent papers with fewer citations. Allow time for citation accumulation or use Mendeley readership as a proxy.
 - **Field boundaries**: Citation chains tend to stay within disciplinary silos. Combine with keyword searches in adjacent-field databases to break out.
-- **Incomplete coverage**: No single database indexes all citations. Cross-check with at least two sources (e.g., Semantic Scholar + Google Scholar).
+- **Incomplete coverage**: No single database indexes all citations. Cross-check with at least two sources (e.g., OpenAlex + Google Scholar).

package/skills/literature/search/database-comparison-guide/SKILL.md

@@ -96,5 +96,5 @@ A robust literature search should query multiple databases to maximize recall:
 
 - **Scopus vs. Web of Science**: Scopus has broader coverage (especially post-2000 and non-English journals); WoS has deeper historical archives and the Journal Impact Factor.
 - **Google Scholar** finds the most results but lacks advanced filtering. Use it for snowball searches and finding grey literature, not as your primary systematic search tool.
-- **API access**: PubMed (E-utilities), Semantic Scholar, OpenAlex, and Crossref all offer free APIs for programmatic searching. Scopus and WoS require institutional API keys.
+- **API access**: PubMed (E-utilities), OpenAlex, and Crossref all offer free APIs for programmatic searching. Scopus and WoS require institutional API keys.
 - **Alert services**: Set up saved search alerts on PubMed, Scopus, and Google Scholar to stay current in fast-moving fields.