The Paper Search MCP server is a Node.js tool that enables searching, retrieving, and downloading academic papers from 14 academic platforms through a unified interface via the Model Context Protocol (MCP).
Multi-Platform Search: Search across arXiv, Web of Science, PubMed, Google Scholar, bioRxiv, medRxiv, Semantic Scholar, IACR ePrint, Sci-Hub, ScienceDirect, Springer Nature, Wiley, Scopus, and Crossref. Use the unified search_papers tool for broad queries or platform-specific tools (search_arxiv, search_webofscience, etc.) for targeted searches.
Advanced Filtering & Sorting: Filter by query string, author, year (single or range), journal, category, fields of study, affiliation, document type, and open access status. Sort results by relevance, date, citations, title, author, or journal in ascending or descending order.
PDF Downloading: Download full-text PDFs using download_paper from arXiv, bioRxiv, medRxiv, Semantic Scholar, IACR ePrint, Sci-Hub, Springer Nature (Open Access), and Wiley.
DOI-based Retrieval: Obtain detailed paper information from multiple platforms using get_paper_by_doi.
Sci-Hub Integration: Access papers with automatic detection of the fastest mirror, continuous health monitoring across 11+ mirrors, and smart failover mechanisms. Check mirror status with check_scihub_mirrors.
Specialized Features: Web of Science advanced queries with 18 field tags (TS, AU, TI, DO, PMID, etc.), PubMed biomedical literature search with publication type filtering, preprint server searches with date filtering, citation data and networks from Google Scholar and Semantic Scholar, and open access filtering.
Unified Data Model: All paper data is standardized with comprehensive metadata including title, authors, abstract, DOI, publication date, citations, journal, keywords, and categories.
Platform Management: Check platform status, validate API keys, and monitor capabilities using get_platform_status.
Security & Performance: DOI validation, query sanitization, injection prevention, API key masking, rate limiting with token bucket algorithm, smart error handling with retry logic and platform fallback, and ethical use warnings for Sci-Hub and Google Scholar.
MCP Integration: Seamlessly integrates with AI assistants like Claude Desktop for enhanced research functionality.
Enables searching and downloading physics and computer science preprints, with support for full-text PDF downloads and metadata retrieval.
Provides access to Web of Science database with advanced search capabilities including multi-topic queries, field tag support, year range filtering, and citation sorting.
Allows paper retrieval and information lookup using DOI identifiers across multiple academic platforms with validation and security checks.
Enables searching ScienceDirect full-text database and Scopus citation database with filters for open access content, authors, and document types.
Enables comprehensive academic search across publishers with citation data, automatic filtering for peer-reviewed papers, and year range queries.
Enables searching and downloading open access papers from Springer Nature's OpenAccess API, bioRxiv, and medRxiv preprint servers.
Allows searching biomedical literature from PubMed/MEDLINE database with filters for authors, journals, publication types, and date ranges.
Provides access to the largest citation database with advanced filtering by affiliation, document type, and comprehensive citation metrics.
Provides AI-powered semantic search with citation networks, research field filtering, and direct access to open access PDFs.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Paper Search MCP find recent papers about large language model alignment"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Node.js Model Context Protocol (MCP) server for searching and downloading academic papers from multiple sources, including arXiv, Web of Science, PubMed, Google Scholar, Sci-Hub, ScienceDirect, Springer, Wiley, Scopus, Crossref, and 14 academic platforms in total.
Related MCP server: Paper Search MCP
π 14 Academic Platforms: arXiv, Web of Science, PubMed, Google Scholar, bioRxiv, medRxiv, Semantic Scholar, IACR ePrint, Sci-Hub, ScienceDirect, Springer Nature, Wiley, Scopus, Crossref
π MCP Protocol Integration: Seamless integration with Claude Desktop and other AI assistants
π Unified Data Model: Standardized paper format across all platforms
β‘ High-Performance Search: Concurrent search with intelligent rate limiting
π‘οΈ Security First: DOI validation, query sanitization, injection prevention, sensitive data masking
π Type Safety: Complete TypeScript support with extended interfaces
π― Academic Papers First: Smart filtering prioritizing academic papers over books
π Smart Error Handling: Unified ErrorHandler with retry logic and platform fallback
Platform | Search | Download | Full Text | Citations | API Key | Special Features |
Crossref | β | β | β | β | β | Default search, extensive metadata coverage |
arXiv | β | β | β | β | β | Physics/CS preprints |
Web of Science | β | β | β | β | β Required | Multi-topic search, date sorting, year ranges |
PubMed | β | β | β | β | π‘ Optional | Biomedical literature |
Google Scholar | β | β | β | β | β | Comprehensive academic search |
bioRxiv | β | β | β | β | β | Biology preprints |
medRxiv | β | β | β | β | β | Medical preprints |
Semantic Scholar | β | β | β | β | π‘ Optional | AI semantic search |
IACR ePrint | β | β | β | β | β | Cryptography papers |
Sci-Hub | β | β | β | β | β | Universal paper access via DOI |
ScienceDirect | β | β | β | β | β Required | Elsevier's full-text database |
Springer Nature | β | β * | β | β | β Required | Dual API: Meta v2 & OpenAccess |
Wiley | β | β | β | β | β Required | TDM API: DOI-based PDF download only |
Scopus | β | β | β | β | β Required | Largest citation database |
β Supported | β Not supported | π‘ Optional | β * Open Access only
Note: Wiley TDM API does not support keyword search. Use
search_crossrefto find Wiley articles, then usedownload_paperwithplatform="wiley"to download PDFs by DOI.
This project includes integrations that may have legal, contractual (ToS), and ethical constraints. You are responsible for ensuring your usage complies with applicable laws, institutional policies, and thirdβparty terms.
Sci-Hub: May provide access to copyrighted works without authorization in many jurisdictions. Use only when you have the legal right to access the content (e.g., open access, authorβprovided copies, or licensed institutional access).
Google Scholar: This integration relies on automated fetching/parsing and may violate Google's Terms of Service or trigger blocking/rate limits. Prefer official APIs or metadata sources (e.g., Crossref, Semantic Scholar) when ToS compliance is required.
Node.js >= 18.0.0
npm or yarn
# Clone repository
git clone https://github.com/your-username/paper-search-mcp-nodejs.git
cd paper-search-mcp-nodejs
# Install dependencies
npm install
# Copy environment template
cp .env.example .envGet Web of Science API Key
Register and apply for Web of Science API access
Add API key to .env file
Get PubMed API Key (Optional)
Without API key: Free usage, 3 requests/second limit
With API key: 10 requests/second, more stable service
Get key: See NCBI API Keys
Configure Environment Variables
# Edit .env file
WOS_API_KEY=your_actual_api_key_here
WOS_API_VERSION=v1
# PubMed API key (optional, recommended for better performance)
PUBMED_API_KEY=your_ncbi_api_key_here
# Semantic Scholar API key (optional, increases rate limits)
SEMANTIC_SCHOLAR_API_KEY=your_semantic_scholar_api_key
# Elsevier API key (required for ScienceDirect and Scopus)
ELSEVIER_API_KEY=your_elsevier_api_key
# Springer Nature API keys (required for Springer)
SPRINGER_API_KEY=your_springer_api_key # For Metadata API v2
# Optional: Separate key for OpenAccess API (if different from main key)
SPRINGER_OPENACCESS_API_KEY=your_openaccess_api_key
# Wiley TDM token (required for Wiley)
WILEY_TDM_TOKEN=your_wiley_tdm_token# Direct run with npx (most common MCP deployment)
npx -y paper-search-mcp-nodejs
# Or install globally
npm install -g paper-search-mcp-nodejs
paper-search-mcp# Build TypeScript code
npm run build
# Start server
npm start
# Or run in development mode
npm run devAdd the following configuration to your Claude Desktop config file:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"paper-search-nodejs": {
"command": "npx",
"args": ["-y", "paper-search-mcp-nodejs"],
"env": {
"WOS_API_KEY": "your_web_of_science_api_key"
}
}
}
}{
"mcpServers": {
"paper_search_nodejs": {
"command": "node",
"args": ["/path/to/paper-search-mcp-nodejs/dist/server.js"],
"env": {
"WOS_API_KEY": "your_web_of_science_api_key"
}
}
}
}search_papersSearch academic papers across multiple platforms
// Random platform selection (default behavior)
search_papers({
query: "machine learning",
platform: "all", // Randomly selects one platform for efficiency
maxResults: 10,
year: "2023",
sortBy: "date"
})
// Search specific platform
search_papers({
query: "quantum computing",
platform: "webofscience", // Target specific platform
maxResults: 5
})Platform Selection Behavior:
platform: "crossref" (default) - Free API with extensive scholarly metadata coverage
platform: "all" - Randomly selects one platform for efficient, focused results
Specific platform - Searches only that platform
Available platforms: crossref, arxiv, webofscience/wos, pubmed, biorxiv, medrxiv, semantic, iacr, googlescholar/scholar, scihub, sciencedirect, springer, scopus
Note: wiley only supports PDF download by DOI, not keyword search
search_crossrefSearch academic papers from Crossref database (default search platform)
search_crossref({
query: "machine learning",
maxResults: 10,
year: "2023",
author: "Smith",
sortBy: "relevance", // or "date", "citations"
sortOrder: "desc"
})search_arxivSearch arXiv preprints specifically
search_arxiv({
query: "transformer neural networks",
maxResults: 10,
category: "cs.AI",
author: "Vaswani",
year: "2023",
sortBy: "date", // relevance, date, citations
sortOrder: "desc" // asc, desc
})search_webofscienceSearch Web of Science database specifically
search_webofscience({
query: "CRISPR gene editing",
maxResults: 15,
year: "2022",
journal: "Nature"
})search_pubmedSearch PubMed/MEDLINE biomedical literature database
search_pubmed({
query: "COVID-19 vaccine efficacy",
maxResults: 20,
year: "2023",
author: "Smith",
journal: "New England Journal of Medicine",
publicationType: ["Journal Article", "Clinical Trial"],
sortBy: "date" // relevance, date
})search_google_scholarSearch Google Scholar academic database
search_google_scholar({
query: "machine learning",
maxResults: 10,
yearLow: 2020,
yearHigh: 2023,
author: "Bengio"
})search_biorxiv / search_medrxivSearch biology and medical preprints
search_biorxiv({
query: "CRISPR",
maxResults: 15,
days: 30,
category: "genomics" // neuroscience, genomics, etc.
})
search_medrxiv({
query: "COVID-19",
maxResults: 10,
days: 30,
category: "infectious_diseases"
})search_semantic_scholarSearch Semantic Scholar AI semantic database
search_semantic_scholar({
query: "deep learning",
maxResults: 10,
fieldsOfStudy: ["Computer Science"],
year: "2023"
})search_iacrSearch IACR ePrint cryptography archive
search_iacr({
query: "zero knowledge proof",
maxResults: 5,
fetchDetails: true
})search_scihubSearch and download papers from Sci-Hub using DOI or paper URL
search_scihub({
doiOrUrl: "10.1038/nature12373",
downloadPdf: true,
savePath: "./downloads"
})search_sciencedirectSearch Elsevier ScienceDirect database
search_sciencedirect({
query: "artificial intelligence",
maxResults: 10,
year: "2023",
author: "Smith",
openAccess: true // Filter for open access articles
})search_springerSearch Springer Nature database (Metadata API v2 or OpenAccess API)
search_springer({
query: "machine learning",
maxResults: 10,
year: "2023",
openAccess: true, // Use OpenAccess API for downloadable PDFs
type: "Journal" // Filter: Journal, Book, or Chapter
})search_scopusSearch Scopus citation database
search_scopus({
query: "renewable energy",
maxResults: 10,
year: "2023",
affiliation: "MIT",
documentType: "ar" // ar=article, cp=conference, re=review
})check_scihub_mirrorsCheck health status of Sci-Hub mirror sites
check_scihub_mirrors({
forceCheck: true // Force fresh health check
})download_paperDownload paper PDF files
download_paper({
paperId: "2106.12345", // or DOI for Sci-Hub
platform: "arxiv", // or "scihub" for Sci-Hub downloads
savePath: "./downloads"
})get_paper_by_doiGet paper information by DOI
get_paper_by_doi({
doi: "10.1038/s41586-023-12345-6",
platform: "all"
})get_platform_statusCheck platform status and API keys
get_platform_status({})All platform paper data is converted to a unified format:
interface Paper {
paperId: string; // Unique identifier
title: string; // Paper title
authors: string[]; // Author list
abstract: string; // Abstract
doi: string; // DOI
publishedDate: Date; // Publication date
pdfUrl: string; // PDF link
url: string; // Paper page URL
source: string; // Source platform
citationCount?: number; // Citation count
journal?: string; // Journal name
year?: number; // Publication year
categories?: string[]; // Subject categories
keywords?: string[]; // Keywords
// ... more fields
}src/
βββ models/
β βββ Paper.ts # Paper data model
βββ platforms/
β βββ PaperSource.ts # Abstract base class
β βββ ArxivSearcher.ts # arXiv searcher
β βββ WebOfScienceSearcher.ts # Web of Science searcher
β βββ PubMedSearcher.ts # PubMed searcher
β βββ GoogleScholarSearcher.ts # Google Scholar searcher
β βββ BioRxivSearcher.ts # bioRxiv/medRxiv searcher
β βββ SemanticScholarSearcher.ts # Semantic Scholar searcher
β βββ IACRSearcher.ts # IACR ePrint searcher
β βββ SciHubSearcher.ts # Sci-Hub searcher with mirror management
β βββ ScienceDirectSearcher.ts # ScienceDirect (Elsevier) searcher
β βββ SpringerSearcher.ts # Springer Nature searcher (Meta v2 & OpenAccess APIs)
β βββ WileySearcher.ts # Wiley TDM API (DOI-based PDF download only)
β βββ ScopusSearcher.ts # Scopus citation database searcher
β βββ CrossrefSearcher.ts # Crossref API searcher (default platform)
βββ mcp/
β βββ tools.ts # MCP tool definitions
β βββ schemas.ts # Zod schemas for tool arguments
β βββ handleToolCall.ts # Tool call dispatcher
β βββ searchers.ts # Searcher initialization
βββ utils/
β βββ SecurityUtils.ts # DOI validation, query sanitization, injection prevention
β βββ ErrorHandler.ts # Unified error handling with retry logic
β βββ RateLimiter.ts # Token bucket rate limiting
β βββ QuotaManager.ts # Daily quota tracking
β βββ RequestCache.ts # LRU caching for requests
β βββ PDFExtractor.ts # PDF text extraction
β βββ Logger.ts # Debug logging
βββ config/
β βββ constants.ts # Timeouts, endpoints, limits
βββ services/
β βββ CitationService.ts # Citation fetching service
βββ server.ts # MCP server main fileCreate new searcher class extending PaperSource
Implement required abstract methods
Register new searcher in searchers.ts
Add corresponding MCP tool in tools.ts
All DOIs are validated before use in URLs
Query parameters are escaped to prevent injection
API keys are masked in all log output
Request timeouts prevent hanging connections
Query complexity limits prevent DoS attacks
Rate limiting and quota management prevent API abuse
Caching reduces external API calls
# Run tests
npm test
# Run linting
npm run lint
# Code formatting
npm run formatTest Coverage:
19 test suites, 158 test cases
All 13 platform searchers tested
Security utilities (DOI validation, query sanitization)
ErrorHandler (error classification, retry logic)
Rate limiting integration, QuotaManager, RequestCache
Test Suite | Coverage |
Platform Searchers | 13/13 β |
SecurityUtils | β |
ErrorHandler | β |
RateLimiter & Integration | β |
QuotaManager | β |
RequestCache | β |
Springer Nature provides two APIs:
Metadata API v2 (Main API)
Endpoint: https://api.springernature.com/meta/v2/json
Searches all Springer content (subscription + open access)
Requires API key from https://dev.springernature.com/
OpenAccess API (Optional)
Endpoint: https://api.springernature.com/openaccess/json
Only searches open access content
May require separate API key or special permissions
Better for finding downloadable PDFs
// Search all Springer content
search_springer({
query: "machine learning",
maxResults: 10
})
// Search only open access papers
search_springer({
query: "COVID-19",
openAccess: true, // Uses OpenAccess API if available
maxResults: 5
})π― WoS Starter API v1/v2 Support: Uses Clarivate's WoS Starter API with full field tag support.
API Version Configuration:
# In .env file (default: v1)
WOS_API_VERSION=v1 # Stable, recommended
# WOS_API_VERSION=v2 # Newer version, same endpoints// Multi-topic search
search_webofscience({
query: 'oriented structure',
year: '2023-2025',
sortBy: 'date',
sortOrder: 'desc',
maxResults: 10
})
// Year range filtering
search_webofscience({
query: 'machine learning',
year: '2020-2024', // Supports range format
sortBy: 'citations',
sortOrder: 'desc'
})
// Advanced query with filters
search_webofscience({
query: 'blockchain',
author: 'zhang',
journal: 'Nature',
year: '2023',
sortBy: 'date',
sortOrder: 'desc'
})
// Traditional WOS query syntax with field tags
search_webofscience({
query: 'TS="machine learning" AND PY=2023 AND DT="Article"',
maxResults: 20
})π§ v0.2.7 Improvements:
β
Google Scholar: Major anti-detection overhaul β session management, cookie persistence, 429/captcha detection with auto-retry, adaptive delay, and proxy support (SCHOLAR_PROXY/HTTPS_PROXY/HTTP_PROXY)
β
arXiv: Fixed search query prefix (all:) to comply with arXiv API spec
β Google Scholar: Updated User-Agents to latest browser versions (Chrome 131, Firefox 133, Edge 131)
β
Performance: Implemented RequestCache for caching search results and API responses
β
Reliability: Added RateLimiter and QuotaManager to prevent API abuse and 429 errors
β
New Features: Added CitationService and PDFExtractor for future enhancements
β
Testing: Restructured test suite into tests/platforms, tests/utils, and tests/integration
β 18 Field Tags: Full support for all WoS Starter API field tags
β API Version Selection: Support for both v1 and v2 endpoints
β Enhanced Filtering: ISSN, Volume, Page, Issue, DocType, PMID filters
β Query Validation: Security checks for query complexity and injection prevention
Supported Search Options:
query: Search terms (supports multi-topic)
year: Single year "2023" or range "2020-2023"
author: Author name filtering
journal: Journal/source filtering
sortBy: Sort field (date, citations, relevance, title, author, journal)
sortOrder: Sort direction (asc, desc)
maxResults: Maximum results (1-50 per page)
Supported WOS Field Tags (18 total):
Tag | Description | Tag | Description |
| Topic (title, abstract, keywords) |
| Title |
| Author |
| Author Identifier |
| Source/Journal |
| ISSN/ISBN |
| Publication Year |
| Final Publication Year |
| DOI |
| Date of Publication |
| Volume |
| Page |
| Issue |
| Document Type |
| PubMed ID |
| Accession Number |
| Organization |
| Source URL |
Example with Field Tags:
// Search by PMID
search_webofscience({ query: 'PMID=12345678' })
// Search by DOI
search_webofscience({ query: 'DO="10.1038/nature12373"' })
// Filter by document type
search_webofscience({ query: 'TS="CRISPR" AND DT="Review"' })
// Search specific volume/issue
search_webofscience({ query: 'SO="Nature" AND VL=580 AND CS=7805' })π§ Debugging WOS Issues:
# Enable debug logging
export NODE_ENV=development
# In CI, logDebug is enabled automatically when CI=trueAcademic Paper Priority: Automatically filters out books, prioritizes peer-reviewed papers
Citation Data: Provides citation counts and academic metrics
Anti-Detection: Smart request patterns to avoid blocking
Session Management: Cookie persistence across requests to mimic real browser behavior
Adaptive Delay: Dynamic backoff that increases on consecutive failures
429/Captcha Detection: Detects rate-limit and captcha responses, resets session and retries
Proxy Support: Optional HTTP/HTTPS/SOCKS proxy to bypass IP-based blocking
Comprehensive Coverage: Searches across all academic publishers
Google Scholar Blocking: Google aggressively blocks direct programmatic access by IP. If searches fail with rate-limit/captcha errors, configure a proxy via the
SCHOLAR_PROXYenvironment variable (also falls back toHTTPS_PROXY/HTTP_PROXY):# HTTP/HTTPS proxy SCHOLAR_PROXY=http://user:pass@host:port # SOCKS proxy SCHOLAR_PROXY=socks://host:portRequired packages are loaded lazily (
http-proxy-agent,https-proxy-agent,socks-proxy-agent) β install the one matching your proxy type.
AI-Powered Search: Semantic understanding of queries
Citation Networks: Paper relationships and influence metrics
Open Access PDFs: Direct links to freely available papers
Research Fields: Filter by specific academic disciplines
Universal Access: Access papers using DOI or direct URLs
Mirror Network: Automatic detection and use of fastest available mirror (11+ mirrors)
Health Monitoring: Continuous monitoring of mirror site availability
Automatic Failover: Seamless switching between mirrors when one fails
Smart Retry: Automatic retry with different mirrors on failure
Response Time Optimization: Mirrors sorted by response time for best performance
MIT License - see LICENSE file for details.
Contributions welcome! See CONTRIBUTING.md for guidelines.
Fork the project
Create feature branch (git checkout -b feature/amazing-feature)
Commit changes (git commit -m 'Add amazing feature')
Push to branch (git push origin feature/amazing-feature)
Open Pull Request
If you encounter issues, please report them at GitHub Issues.
Original paper-search-mcp for the foundation
MCP community for the protocol standards
β If this project helps you, please give it a star!
Check the health status of all Sci-Hub mirror sites
| Name | Required | Description | Default |
|---|---|---|---|
| forceCheck | No | Force a fresh health check even if recent data exists |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool checks health status, implying a read-only operation, but doesn't specify what 'health status' entails (e.g., uptime, response time), whether it's cached or real-time, or any rate limits. For a tool with no annotations, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence: 'Check the health status of all Sci-Hub mirror sites.' It's front-loaded with the core purpose, has zero wasted words, and is appropriately sized for the tool's simplicity, making it highly efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete. It doesn't explain what the health check returns (e.g., a list of mirrors with statuses), how results are formatted, or any behavioral nuances. For a tool that likely outputs structured data, this leaves the agent guessing about the tool's full functionality.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the parameter 'forceCheck' well-documented in the schema. The description doesn't add any meaning beyond this, as it mentions no parameters. Given the high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't need to.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Check the health status of all Sci-Hub mirror sites.' It specifies the verb ('check') and resource ('Sci-Hub mirror sites'), distinguishing it from sibling tools focused on searching or downloading papers. However, it doesn't explicitly differentiate from 'get_platform_status,' which might be a related sibling, so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, timing, or comparisons with siblings like 'get_platform_status' or 'search_scihub,' leaving the agent to infer usage based on the name alone. This lack of explicit context reduces its helpfulness.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Download PDF file of an academic paper
| Name | Required | Description | Default |
|---|---|---|---|
| paperId | Yes | Paper ID (e.g., arXiv ID, DOI for Sci-Hub) | |
| platform | Yes | Platform where the paper is from | |
| savePath | No | Directory to save the PDF file |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the action ('Download PDF file') but lacks critical behavioral details: whether this requires authentication, potential rate limits, file size considerations, or what happens on failure (e.g., if the paper isn't found). For a download operation with no annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of downloading files across multiple platforms and no annotations or output schema, the description is incomplete. It doesn't address error handling, return values (e.g., success confirmation or file path), or platform-specific behaviors, which are crucial for a tool with 3 parameters and varied platforms.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds no additional meaning about parameters beyond implying they're needed for downloading. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Download') and resource ('PDF file of an academic paper'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_paper_by_doi' or 'search_arxiv', which might also retrieve papers but perhaps in different formats or contexts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With many sibling tools for searching and retrieving papers, it's unclear if this is the primary download method or if others like 'get_paper_by_doi' serve similar purposes. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve citation data (citation count, references, venue) for a paper by DOI using Semantic Scholar
| Name | Required | Description | Default |
|---|---|---|---|
| doi | Yes | DOI (Digital Object Identifier) | |
| forceRefresh | No | Bypass the cache and fetch fresh data (default: false) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the full burden. It confirms it is a read operation (no side effects), but it does not disclose caching behavior, rate limits, or error handling. The mention of Semantic Scholar implies an external dependency but no caveats. This is a modest gap given the simple nature of the tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that is front-loaded with the core action and output, followed by the input method and source. No wasted words, length is appropriate for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 2 parameters, no output schema, and no annotations, the description provides sufficient context: it specifies what data is returned and that input is a DOI. The forceRefresh parameter is explained in the schema, and the description implies a single-paper lookup. Missing details like potential errors or rate limits are minor for this scope, making the description complete enough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters (doi, forceRefresh) already documented in the schema. The description adds minimal extra meaning beyond confirming the DOI is for the paper and that data comes from Semantic Scholar. Since the schema fully covers parameters, the baseline of 3 is appropriate; the description does not enhance parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (retrieve citation data), the specific resource (a paper by DOI), and the data fields returned (citation count, references, venue). It also names the external service (Semantic Scholar), which distinguishes it from siblings like get_paper_by_doi that likely return different metadata.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly conveys when to use it: when you have a DOI and need citation metrics. It does not explicitly mention when not to use it or alternatives, but the phrase 'citation data' differentiates it from general paper lookups. No exclusions are given, but the context is clear enough for an agent to choose it over search tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve paper information using DOI from available platforms
| Name | Required | Description | Default |
|---|---|---|---|
| doi | Yes | DOI (Digital Object Identifier) | |
| platform | No | Platform to search |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves information, implying a read-only operation, but doesn't clarify aspects like rate limits, authentication needs, error handling, or what 'available platforms' entails. For a tool with no annotations, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded in a single sentence: 'Retrieve paper information using DOI from available platforms.' It efficiently communicates the core purpose without unnecessary details. However, it could be slightly more structured by explicitly mentioning the parameters or usage context, but it's not wasteful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete. It doesn't explain what 'paper information' includes (e.g., metadata, abstract, citations), how results are returned, or any limitations (e.g., platform availability). For a retrieval tool with multiple sibling alternatives, more context is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters (doi and platform) with descriptions and an enum for platform. The description adds marginal value by mentioning 'available platforms,' which loosely relates to the platform parameter, but doesn't provide additional semantics beyond what the schema offers. Baseline 3 is appropriate given high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Retrieve paper information using DOI from available platforms.' It specifies the action (retrieve), resource (paper information), and key input (DOI). However, it doesn't explicitly differentiate from sibling tools like 'search_crossref' or 'search_semantic_scholar' that might also retrieve paper information, though the DOI focus provides some distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides minimal guidance: it implies use when you have a DOI and want paper information from platforms. It doesn't specify when to use this tool versus alternatives (e.g., 'search_crossref' for DOI-based searches or 'search_arxiv' for arXiv-specific queries), nor does it mention prerequisites or exclusions. This lack of explicit context reduces its helpfulness for an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check the status and capabilities of available academic platforms
| Name | Required | Description | Default |
|---|---|---|---|
| validate | No | Whether to validate configured API keys by making a real request (may trigger rate limits). Default: false. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'Check' implies a read-only operation, it doesn't specify what 'status and capabilities' includes (uptime, rate limits, authentication requirements, available features). The description mentions capabilities but doesn't detail what information is returned or any behavioral constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the core purpose without unnecessary words. It's appropriately sized for a simple status-checking tool and front-loads the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what 'status and capabilities' means in practice, what format the information is returned in, or how this differs from the many search-focused sibling tools. The agent would need to guess about the tool's behavior and output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage for the single parameter, the schema already fully documents the 'validate' parameter. The description adds no additional parameter information beyond what's in the schema, so it meets the baseline expectation but doesn't provide extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Check') and resource ('status and capabilities of available academic platforms'), making it immediately understandable. However, it doesn't explicitly distinguish this from sibling tools that focus on searching or downloading content rather than platform status checking.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With many sibling tools focused on searching specific databases, there's no indication whether this should be used before attempting searches, when troubleshooting, or as a general health check. The lack of usage context is a significant gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search academic papers specifically from arXiv preprint server
| Name | Required | Description | Default |
|---|---|---|---|
| year | No | Year filter (e.g., "2023", "2020-2023") | |
| query | Yes | Search query string | |
| author | No | Author name filter | |
| sortBy | No | Sort results by field | |
| category | No | arXiv category filter (e.g., cs.AI, physics.gen-ph) | |
| sortOrder | No | Sort order: ascending or descending | |
| maxResults | No | Maximum number of results to return |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Search' implies a read-only operation, the description provides no information about rate limits, authentication requirements, result format, pagination, error conditions, or what happens when no results are found. This is a significant gap for a search tool with many parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that gets straight to the point. There's no wasted language or unnecessary elaboration - it clearly communicates the core function without any fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with 7 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what kind of results to expect, how results are structured, whether there are limitations or constraints, or how this tool differs from the many other search tools available. The context demands more guidance than what's provided.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 100% description coverage, so all parameters are well-documented in the structured schema. The description doesn't add any parameter-specific information beyond what's already in the schema, which is acceptable given the comprehensive schema coverage. The baseline of 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Search') and resource ('academic papers from arXiv preprint server'), making the purpose immediately understandable. However, it doesn't distinguish this tool from its many sibling search tools (like search_biorxiv, search_pubmed, etc.) beyond mentioning arXiv specifically.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance about when to use this tool versus the many alternative search tools available on the server. There's no mention of when arXiv search is preferable to other academic databases or what makes this tool distinct from its siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search bioRxiv preprint server for biology papers
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Number of days to search back (default: 30) | |
| query | Yes | Search query string | |
| category | No | Category filter (e.g., neuroscience, genomics) | |
| maxResults | No | Maximum number of results to return |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action 'search' but doesn't describe what the search returns (e.g., list of papers, metadata), any rate limits, authentication needs, or error conditions. This is a significant gap for a search tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It is appropriately sized and front-loaded, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a search tool with 4 parameters, no annotations, and no output schema, the description is minimally adequate. It clarifies the domain (bioRxiv, biology papers) but lacks details on return values, behavioral traits, or usage context, which are important for effective tool selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with all parameters well-documented in the input schema (e.g., query string, maxResults range, days default, category examples). The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'search' and the resource 'bioRxiv preprint server for biology papers', which is specific and unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'search_medrxiv' or 'search_papers', which might have overlapping domains or purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'search_medrxiv' (for medical preprints) or 'search_pubmed' (for published papers). It lacks explicit context, exclusions, or prerequisites, leaving the agent to infer usage based on the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search academic papers from Crossref database. Free API with extensive scholarly metadata coverage across publishers.
| Name | Required | Description | Default |
|---|---|---|---|
| year | No | Year filter (e.g., "2023", "2020-2023") | |
| query | Yes | Search query string | |
| author | No | Author name filter | |
| sortBy | No | Sort results by relevance, date, or citations | |
| sortOrder | No | Sort order: ascending or descending | |
| maxResults | No | Maximum number of results to return |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the API is 'free' and has 'extensive coverage,' which adds some context about cost and scope, but it doesn't cover critical behaviors like rate limits, authentication needs, error handling, or response format. For a search tool with no annotation coverage, this leaves significant gaps in understanding how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, with two sentences that efficiently convey the core purpose and key features (free API, extensive coverage). There's no wasted text, and it avoids redundancy. However, it could be slightly more structured by explicitly separating purpose from behavioral context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (6 parameters, no output schema, no annotations), the description is somewhat complete but has gaps. It covers the purpose and high-level context but lacks details on behavioral traits and usage guidelines. Without an output schema, it doesn't explain return values, which is a missed opportunity to add value beyond structured fields.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, meaning all parameters are documented in the input schema. The description doesn't add any specific parameter semantics beyond what the schema provides (e.g., it doesn't explain query syntax or year format details). According to the rules, with high schema coverage (>80%), the baseline is 3 even without param info in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Search academic papers from Crossref database.' It specifies the verb ('search'), resource ('academic papers'), and data source ('Crossref database'), making the intent unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'search_papers' or 'search_semantic_scholar' that might also search academic papers, which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides minimal usage guidance. It mentions that the API is 'free' and has 'extensive scholarly metadata coverage,' which hints at when to use it (e.g., for broad, cost-effective searches), but it doesn't explicitly state when to choose this tool over alternatives like 'search_pubmed' or 'search_arxiv' from the sibling list. No exclusions or specific contexts are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Google Scholar for academic papers using web scraping
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query string | |
| author | No | Author name filter | |
| yearLow | No | Earliest publication year | |
| yearHigh | No | Latest publication year | |
| maxResults | No | Maximum number of results to return |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only mentions 'web scraping' without detailing behavioral traits like rate limits, authentication needs, or potential risks (e.g., blocking). It lacks information on response format, error handling, or operational constraints, leaving significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero wasteβit directly states the tool's function and method. It's appropriately sized and front-loaded, making it easy to grasp immediately without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a search tool with 5 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain return values, error cases, or how results are structured, which is critical for an agent to use the tool effectively. The 'web scraping' hint is insufficient for full context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 5 parameters. The description adds no additional meaning beyond the schema, such as query syntax examples or interactions between parameters like yearLow and yearHigh. Baseline 3 is appropriate as the schema handles parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('search') and resource ('Google Scholar for academic papers'), making the purpose understandable. However, it doesn't differentiate from sibling tools like search_arxiv or search_pubmed, which perform similar academic searches on different platforms, so it misses full distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as search_arxiv for physics papers or search_pubmed for medical literature. It mentions 'web scraping' but doesn't explain implications or exclusions, leaving usage context vague.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search IACR ePrint Archive for cryptography papers
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query string | |
| maxResults | No | Maximum number of results to return | |
| fetchDetails | No | Fetch detailed information for each paper (slower) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'Search' but doesn't describe what the search returns (e.g., paper titles, abstracts, metadata), performance characteristics (e.g., speed implications of fetchDetails), error conditions, or authentication requirements. The phrase 'slower' in the schema hints at performance but isn't elaborated in the description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It's front-loaded with the core action and target, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with 3 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what the search returns (e.g., list of papers with basic info), how results are formatted, or any limitations (e.g., date ranges, sorting options). The lack of output schema means the description should compensate by detailing return values, which it doesn't.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters (query, maxResults, fetchDetails) with their types and constraints. The description adds no additional parameter semantics beyond what's in the schema, maintaining the baseline score of 3 for adequate coverage through structured data alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Search') and resource ('IACR ePrint Archive for cryptography papers'), making the purpose immediately understandable. It distinguishes from general search tools by specifying the IACR ePrint Archive, though it doesn't explicitly differentiate from sibling tools like search_arxiv that also search academic repositories.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With many sibling search tools (e.g., search_arxiv, search_pubmed, search_google_scholar), there's no indication that this is specifically for cryptography papers from IACR, nor any context about when it might be preferred over other search options.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search medRxiv preprint server for medical papers
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Number of days to search back (default: 30) | |
| query | Yes | Search query string | |
| category | No | Category filter (e.g., infectious_diseases, epidemiology) | |
| maxResults | No | Maximum number of results to return |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure but provides minimal information. It doesn't mention rate limits, authentication requirements, response format, pagination behavior, or what happens when no results are found. For a search tool with no annotation coverage, this leaves significant behavioral questions unanswered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the core purpose without any wasted words. It's appropriately sized for a search tool and front-loads the essential information. Every word earns its place in this concise formulation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of having 18 sibling tools (many of which are similar search tools) and no annotations or output schema, the description is insufficiently complete. It doesn't help the agent navigate the crowded tool ecosystem or understand medRxiv's specific value proposition versus other repositories. For a search tool among many alternatives, more contextual guidance is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no parameter information beyond what's already in the schema, which has 100% coverage with clear descriptions for all 4 parameters. The baseline is 3 when schema coverage is high (>80%), and the description doesn't compensate with additional context about how parameters interact or search behavior nuances.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Search') and resource ('medRxiv preprint server for medical papers'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from its many sibling search tools (like search_arxiv, search_biorxiv, search_pubmed, etc.), which all search different repositories. A perfect score would require distinguishing this specific medRxiv search from other similar search tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance about when to use this tool versus its many sibling search tools. With 18 sibling tools including multiple search tools for different repositories (medRxiv, arXiv, bioRxiv, PubMed, etc.), the agent receives no help in choosing between them. There's no mention of medRxiv's specific focus (medical preprints) versus other databases' scopes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search academic papers from multiple sources including arXiv, Web of Science, etc.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Number of days to search back (bioRxiv/medRxiv only) | |
| year | No | Year filter (e.g., "2023", "2020-2023", "2020-") | |
| query | Yes | Search query string | |
| author | No | Author name filter | |
| sortBy | No | Sort results by relevance, date, or citations | |
| journal | No | Journal name filter | |
| category | No | Category filter (e.g., cs.AI for arXiv) | |
| platform | No | Platform to search (default: crossref). Options: arxiv, webofscience/wos, pubmed, biorxiv, medrxiv, semantic, iacr, googlescholar/scholar, scihub, sciencedirect, springer, scopus, crossref, or all. Note: Wiley only supports PDF download by DOI, use download_paper instead. | |
| sortOrder | No | Sort order: ascending or descending | |
| maxResults | No | Maximum number of results to return | |
| fetchDetails | No | Fetch detailed information (IACR only) | |
| fieldsOfStudy | No | Fields of study filter (Semantic Scholar only) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states it 'searches' papers, implying a read-only operation, but doesn't mention any behavioral traits like rate limits, authentication needs, pagination, or what the output looks like (e.g., format, fields returned). For a tool with 12 parameters and no output schema, this leaves significant gaps in understanding how it behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the core functionality without unnecessary words. It's appropriately sized for a search tool, though it could be slightly more informative given the tool's complexity. The structure is front-loaded with the main purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's high complexity (12 parameters, many siblings, no output schema, and no annotations), the description is inadequate. It doesn't explain the relationship with sibling tools, output format, or behavioral constraints. For a multi-platform search tool with extensive parameters, more context is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no parameter-specific information beyond implying a multi-source search capability, which relates to the 'platform' parameter. It doesn't provide additional context like default behaviors or parameter interactions, so it meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Search academic papers from multiple sources including arXiv, Web of Science, etc.' It specifies the verb ('search') and resource ('academic papers'), and mentions the multi-source capability. However, it doesn't explicitly differentiate from sibling tools like search_arxiv or search_crossref, which are more specialized versions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus its many siblings (e.g., search_arxiv, search_crossref). It mentions 'multiple sources' but doesn't clarify if this is a unified search across all platforms or how it differs from using individual platform-specific tools. The only usage hint is in the input schema's platform parameter description, which notes 'Wiley only supports PDF download by DOI, use download_paper instead,' but this isn't in the main description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search biomedical literature from PubMed/MEDLINE database using NCBI E-utilities API
| Name | Required | Description | Default |
|---|---|---|---|
| year | No | Publication year filter (e.g., "2023", "2020-2023") | |
| query | Yes | Search query string | |
| author | No | Author name filter | |
| sortBy | No | Sort results by relevance or date | |
| journal | No | Journal name filter | |
| maxResults | No | Maximum number of results to return | |
| publicationType | No | Publication type filter (e.g., ["Journal Article", "Review"]) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the NCBI E-utilities API but doesn't describe rate limits, authentication requirements, pagination behavior, error handling, or what the response format looks like. For a search tool with no annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that clearly states the tool's purpose. There's no wasted language or unnecessary elaboration. However, it could be slightly improved by front-loading more context about when to use this specific PubMed search versus other search tools.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with 7 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what the search returns (abstracts, citations, full metadata?), doesn't mention rate limits or API constraints, and provides no guidance on usage context. The description should do more to compensate for the lack of structured metadata.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 7 parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches biomedical literature from PubMed/MEDLINE using NCBI E-utilities API, providing a specific verb ('Search') and resource ('biomedical literature from PubMed/MEDLINE database'). However, it doesn't explicitly differentiate from sibling tools like search_medrxiv or search_biorxiv that also search biomedical literature, missing sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With many sibling tools available for searching different databases (e.g., search_arxiv, search_google_scholar, search_scopus), there's no indication of when PubMed-specific searching is preferred or what makes this tool distinct from general search tools like search_papers.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search academic papers from Elsevier ScienceDirect database (requires API key)
| Name | Required | Description | Default |
|---|---|---|---|
| year | No | Year filter (e.g., "2023", "2020-2023") | |
| query | Yes | Search query string | |
| author | No | Author name filter | |
| journal | No | Journal name filter | |
| maxResults | No | Maximum number of results to return | |
| openAccess | No | Filter for open access articles only |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It only mentions the API key requirement, but doesn't describe what the search returns (e.g., metadata, abstracts, full text availability), pagination behavior, rate limits, authentication scope, or error conditions. This leaves significant gaps for a search tool with 6 parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the core purpose and key requirement. It's appropriately sized and front-loaded with the main functionality, though it could potentially be more structured with separate usage notes.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with 6 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what kind of results are returned, how they're formatted, whether there's pagination, or any limitations. The API key mention is helpful but insufficient for full contextual understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema, maintaining the baseline score of 3 for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches academic papers from the Elsevier ScienceDirect database, which is a specific verb (search) and resource (academic papers from ScienceDirect). It distinguishes from siblings like search_arxiv or search_pubmed by specifying the database source, though it doesn't explicitly contrast with all similar search tools in the list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions 'requires API key' which provides some context about prerequisites, but it doesn't offer guidance on when to use this tool versus alternatives like search_scopus or search_semantic_scholar. No explicit when/when-not instructions or comparison to sibling tools are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search and download papers from Sci-Hub using DOI or paper URL. Automatically detects and uses the fastest available mirror.
| Name | Required | Description | Default |
|---|---|---|---|
| doiOrUrl | Yes | DOI (e.g., "10.1038/nature12373") or full paper URL | |
| savePath | No | Directory to save the PDF file (if downloadPdf is true) | |
| downloadPdf | No | Whether to download the PDF file |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: automatic mirror detection and PDF download capability. However, it lacks details on error handling, rate limits, authentication needs, or what happens if download fails, leaving gaps for a mutation-capable tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core functionality ('Search and download papers from Sci-Hub') and adds useful context ('Automatically detects and uses the fastest available mirror') without any wasted words. Every part earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is moderately complete for a tool with 3 parameters and mutation capability (download). It covers the purpose and basic behavior but lacks details on return values, error cases, or advanced usage, which would be helpful for full contextual understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents parameters. The description adds minimal value beyond the schema by implying the tool handles both DOI and URL formats, but does not provide additional syntax or format details. This meets the baseline of 3 for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Search and download papers') and resource ('from Sci-Hub'), distinguishing it from sibling tools like search_arxiv or search_pubmed by specifying the Sci-Hub source. It includes the unique capability of automatic mirror detection, which further differentiates it from generic search tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool: for searching Sci-Hub with DOI or URL inputs. It implicitly suggests alternatives like sibling tools for other sources (e.g., search_arxiv for arXiv), but does not explicitly state when not to use it or name specific alternatives, keeping it at a 4.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the Scopus abstract and citation database (requires Elsevier API key)
| Name | Required | Description | Default |
|---|---|---|---|
| year | No | Year filter (e.g., "2023", "2020-2023") | |
| query | Yes | Search query string | |
| author | No | Author name filter | |
| journal | No | Journal name filter | |
| subject | No | Subject area filter | |
| maxResults | No | Maximum number of results (max 25 per request) | |
| openAccess | No | Filter for open access articles only | |
| affiliation | No | Institution/affiliation filter | |
| documentType | No | Document type: ar=article, cp=conference paper, re=review, bk=book, ch=chapter |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It only mentions the API key requirement but doesn't describe what the search returns (abstracts, citations, metadata), pagination behavior, rate limits, authentication scope, or error conditions. For a search tool with 9 parameters, this leaves significant behavioral aspects unexplained.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the core purpose and key prerequisite without any wasted words. It's appropriately sized and front-loaded with essential information, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a 9-parameter search tool with no annotations and no output schema, the description is insufficient. It doesn't explain what results to expect (format, fields, limitations), how results are ordered, whether there's pagination, or how to interpret the various filters. The API key mention is helpful but doesn't compensate for the missing behavioral context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 9 parameters thoroughly. The description adds no parameter-specific information beyond what's in the schema. The baseline score of 3 reflects adequate coverage through the schema alone, though the description contributes nothing additional about parameter usage or interactions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Search') and target resource ('Scopus abstract and citation database'), making the purpose immediately understandable. It distinguishes from some siblings by specifying the Scopus database, but doesn't explicitly differentiate from other academic search tools like search_arxiv or search_pubmed beyond the database name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus the many sibling search tools available. It mentions the requirement for an Elsevier API key, which is a prerequisite but doesn't help the agent choose between Scopus and alternatives like Google Scholar, PubMed, or other databases for different search scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Semantic Scholar for academic papers with citation data
| Name | Required | Description | Default |
|---|---|---|---|
| year | No | Year filter (e.g., "2023", "2020-2023") | |
| query | Yes | Search query string | |
| maxResults | No | Maximum number of results to return | |
| fieldsOfStudy | No | Fields of study filter (e.g., ["Computer Science", "Biology"]) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'Search' implies a read-only operation, the description doesn't mention important behavioral aspects like rate limits, authentication requirements, response format, pagination behavior, or error conditions. The mention of 'citation data' hints at what's returned but doesn't provide operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the core functionality without unnecessary words. It's appropriately sized for a search tool and front-loads the essential information. Every word earns its place in this concise statement.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with 4 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what kind of results to expect, how citation data is presented, or how this tool differs from the many other search tools available. The lack of behavioral context and usage guidance leaves significant gaps for an AI agent trying to use this tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 4 parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema descriptions. It mentions 'citation data' which relates to output rather than input parameters. Baseline score of 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Search') and resource ('Semantic Scholar for academic papers'), and specifies the type of data returned ('with citation data'). However, it doesn't explicitly differentiate this tool from its many sibling search tools (e.g., search_arxiv, search_pubmed) beyond mentioning Semantic Scholar specifically.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus the many alternative search tools available on the server (search_arxiv, search_pubmed, search_google_scholar, etc.). There's no mention of Semantic Scholar's specific strengths, coverage, or when it might be preferred over other academic search tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search academic papers from Springer Nature database. Uses Metadata API by default (all content) or OpenAccess API when openAccess=true (full text available). Same API key works for both.
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | Publication type filter | |
| year | No | Year filter (e.g., "2023", "2020-2023") | |
| query | Yes | Search query string | |
| author | No | Author name filter | |
| journal | No | Journal name filter | |
| subject | No | Subject area filter | |
| maxResults | No | Maximum number of results to return | |
| openAccess | No | Search only open access content |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses that the same API key works for both API modes, which is useful behavioral context about authentication. However, it doesn't mention rate limits, pagination behavior, error handling, or what the response format looks like, leaving significant gaps for a search tool with 8 parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured in two sentences with zero waste. The first sentence states the core purpose, and the second provides important behavioral context about API modes and authentication. Every sentence earns its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with 8 parameters, no annotations, and no output schema, the description provides adequate basic information about purpose and API behavior. However, it lacks details about response format, error conditions, or performance characteristics that would be helpful given the tool's complexity and lack of structured metadata.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 8 parameters thoroughly. The description adds minimal value by mentioning the openAccess parameter's effect on API selection, but doesn't provide additional semantic context beyond what's in the schema descriptions. Baseline 3 is appropriate when schema does heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches academic papers from Springer Nature database, specifying both the action (search) and resource (academic papers). It distinguishes itself from siblings by mentioning the Springer Nature database specifically, unlike other search tools like search_arxiv or search_pubmed that target different sources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context about when to use different API modes (Metadata API vs OpenAccess API based on openAccess parameter), which helps guide usage. However, it doesn't explicitly state when to choose this tool over sibling search tools like search_google_scholar or search_scopus, missing explicit alternatives guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search academic papers from Web of Science database
| Name | Required | Description | Default |
|---|---|---|---|
| year | No | Publication year filter (e.g., "2023", "2020-2023") | |
| query | Yes | Search query string | |
| author | No | Author name filter | |
| sortBy | No | Sort results by field | |
| journal | No | Journal name filter | |
| sortOrder | No | Sort order: ascending or descending | |
| maxResults | No | Maximum number of results to return |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool searches but doesn't mention rate limits, authentication requirements, pagination behavior, error conditions, or what the output looks like (e.g., format, fields returned). For a search tool with no annotation coverage, this leaves significant gaps in understanding its operational characteristics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It's appropriately sized and front-loaded, making it easy to understand at a glance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a 7-parameter search tool with no annotations and no output schema, the description is insufficient. It doesn't explain what results look like, how they're structured, or any behavioral aspects like rate limits or errors. For a tool interacting with an external academic database, more context about output format and operational constraints is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all 7 parameters well-documented in the schema itself (e.g., query, maxResults, year, author, journal, sortBy, sortOrder). The description adds no additional parameter information beyond what the schema provides, so it meets the baseline of 3 for high schema coverage without compensating value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Search') and resource ('academic papers from Web of Science database'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like search_scopus or search_semantic_scholar, which serve similar purposes for different databases.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. With many sibling tools for searching different academic databases (e.g., search_arxiv, search_pubmed, search_scopus), the description offers no context on Web of Science's specific coverage, strengths, or when it might be preferred over other search tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.2.7-patchget_citationssearch_wileycheck_scihub_mirrorsdownload_paperget_paper_by_doiget_platform_statussearch_arxivsearch_biorxivsearch_crossrefsearch_google_scholarsearch_iacrsearch_medrxivsearch_paperssearch_pubmedsearch_sciencedirectsearch_scihubsearch_scopussearch_semantic_scholarsearch_springersearch_webofsciencesearch_wileyMost tools are clearly distinct by targeting specific databases or actions (search, download, status). However, search_scihub and download_paper have overlapping download capabilities, and get_citations vs search_semantic_scholar both involve citations, creating slight ambiguity. Descriptions mostly help, but a few boundary issues remain.
All tool names follow a consistent verb_noun pattern (e.g., search_arxiv, get_paper_by_doi, check_scihub_mirrors). Verbs are descriptive and match actions, and the style is uniformly lowercase with underscores. No mixing of conventions.
With 19 tools, the server is on the higher end but justified by the need to support many distinct academic sources. Each search tool serves a specific database, avoiding redundancy. The count feels slightly heavy but appropriate for the comprehensive scope.
The tool surface covers the core lifecycle of paper discovery and retrieval: searching across multiple sources, downloading, fetching by DOI, and getting citations. Missing advanced features like reference management or batch operations, but these are auxiliary. Minor gaps exist, such as no dedicated tool for listing references, but the overall coverage is solid.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Search and download academic papers from arXiv, PubMed, bioRxiv, medRxiv, Google Scholar, Semanticβ¦
Find academic papers across major sources like arXiv, PubMed, bioRxiv, and more. Download PDFs wheβ¦
Federated search of books and papers, BibTeX/RIS citations, open-access retrieval and reading.
Search arXiv/Semantic Scholar/OpenAlex + medical evidence (PubMed/Europe PMC) + LaTeX/PDF tools.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Dianel555/paper-search-mcp-nodejs'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
