The scholar-toolkit-mcp server is a comprehensive academic research toolkit for searching, downloading, reading, and managing papers across 20+ platforms, plus manuscript processing and reference management.
Multi-Source Paper Search: Unified search (search_papers) across 20+ platforms simultaneously with deduplication — including arXiv, PubMed, bioRxiv, medRxiv, Semantic Scholar, Crossref, OpenAlex, PMC, CORE, Europe PMC, dblp, OpenAIRE, CiteSeerX, DOAJ, BASE, Zenodo, HAL, SSRN, and Unpaywall. Individual source-specific search functions are also available, with filtering by year, sort order, and other parameters.
Paper Download: Direct PDF downloads from supported platforms (arXiv, bioRxiv, medRxiv, IACR, Semantic Scholar, PMC, CORE, Zenodo, HAL, etc.), plus a robust download_with_fallback chain that tries source-native links → OA repositories → Unpaywall → optional Sci-Hub.
Paper Reading (Text Extraction): Extract full text from papers for supported sources (arXiv, bioRxiv, medRxiv, IACR, Semantic Scholar, CORE, Europe PMC, Zenodo, HAL, CiteSeerX, DOAJ, BASE, OpenAIRE).
Manuscript Processing: Process Markdown files with citation placeholders ([@doi:...], [@pmid:...], [@arxiv:...], [@title:...]) to produce numbered Markdown, BibTeX (refs.bib), RIS (refs.ris), and optionally Word documents (.docx via pandoc). Supports citation styles: GB/T 7714-2015, APA 7th, IEEE, Vancouver, and Harvard.
Paper Metadata & Reference Export: Fetch detailed metadata by DOI, PMID, or arXiv ID (get_paper_metadata), and export reference lists in BibTeX, RIS, or plain text formats.
Search Cache Management: Search results are automatically cached in .paper_cache/ with a configurable TTL (default: 24 hours). Use cache_list to inspect and cache_clear to purge cached results.
Allows searching and downloading papers from arXiv, a preprint repository for scientific articles.
Allows searching papers from dblp, a computer science bibliography.
Allows searching for academic papers and discovering DOIs via Google Scholar.
Allows searching papers from HAL, an open-access archive for scientific documents.
Enables export of references in RIS format compatible with Mendeley reference manager.
Allows searching and retrieving paper metadata from PubMed, a biomedical literature database.
Allows searching papers via Semantic Scholar with metadata enrichment.
Allows searching papers from SSRN, a repository for social science and humanities preprints.
Allows searching papers from Zenodo, a general-purpose open-access repository.
Enables export of references in RIS and BibTeX formats for import into Zotero.
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., "@scholar-toolkit-mcp search for papers on federated learning from arxiv"
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.
English | 中文
A comprehensive MCP toolkit for academic paper searching, manuscript processing, and citation management.
Multi-source search: arXiv, Semantic Scholar, PubMed, Crossref, OpenAlex, PMC, medRxiv, DBLP, Europe PMC, OpenAIRE, SSRN, IEEE, ACM
PDF download with automatic fallback (Unpaywall → OA repositories → Sci-Hub)
Text extraction from PDFs
SQLite-based local library
BibTeX/RIS export
Citation key generation
Author name auto-normalization (Surname, Given format)
Markdown citation placeholder replacement & reference list generation
Human review copy generation (cite_key → Author(Year) DOI)
Multiple citation styles: GB/T 7714-2015, APA 7th, IEEE
Writing templates
30 automated verification rules (R0-R9) with local/global scope
Chinese language enforcement
Citation format validation
Word count checking
Writing/final mode switching (chapter/draft/final)
Multi-model LLM scoring for citation accuracy
Incremental caching to avoid re-verification
Single-citation and full-manuscript batch verification
Related MCP server: Academic Paper MCP HTTP/SSE Server
pip install paper-toolkit-mcpAdd to your MCP client config:
{
"mcpServers": {
"paper-toolkit-mcp": {
"command": "paper-toolkit-mcp",
"env": {
"paper_toolkit_mcp_WORK_DIR": "/path/to/your/project"
}
}
}
}Note: Set
paper_toolkit_mcp_WORK_DIRto your project directory so thatpapers.db, downloads, and cache are stored there.
All sources work without API keys. Optional keys improve rate limits:
# Copy example and fill in available keys
cp .env.example .envSee .env.example for all available keys.
Tool | Description |
| Multi-source search (supports groups: medical/cs/metadata) |
| Get paper metadata by DOI (CrossRef + Semantic Scholar fallback) |
| Download PDF (source-native → OA repos → Unpaywall → Sci-Hub) |
| Download by citation key |
| Download and extract PDF text |
Tool | Description |
| Search local library |
| Get library statistics |
| Clear search cache |
Tool | Description |
| Process Markdown manuscript, replace citation placeholders & generate outputs |
| Get full metadata for a single paper |
| Batch export references (BibTeX/RIS/text) |
| Get writing template |
| Generate reference list from manuscript cite_keys |
| Generate human review copy (cite_key → Author(Year) DOI) |
Tool | Description |
| Initialize harness infrastructure |
| Verify manuscript against rules |
| List all rules (with scope and draft_skip markers) |
Tool | Description |
| Verify a single citation (multi-model LLM scoring) |
| Batch verify all citations in a manuscript |
| Check verifier configuration & model connectivity |
Rule | Category | Scope | Description |
R0 | Language | local | Chinese language enforcement |
R1 | Structure | local | Heading hierarchy, heading length, no lists/bold |
R2 | Data | local/global | P-value, mean±SD, statistics, data consistency |
R3 | Sections | global | Required chapters (intro/methods/results/discussion/conclusion) |
R4 | Terminology | local | Abbreviation consistency, humble phrasing |
R5 | Citations | local/global | cite_key format, density, total reference count |
R6 | Position | local | Citation placement, multi-citation format |
R7 | AI Trace | local | No colon in headings, no self-praise/back-reference, user comments |
R8 | Word Count | local/global | 3000-8000 words total, paragraph length, abstract length |
R9 | Tables/Figures | local/global | Three-line table, 300dpi, figure numbering |
Scope:
localrules can be checked by sub-agents on individual chapters;globalrules require the full merged manuscript. In draft mode, abstract word count (R8.3) and total reference count (R5.4) are automatically skipped.
# Install dev dependencies
pip install -e ".[dev]"
# Run tests
pytest
# Lint
ruff check paper_toolkit_mcp tests
# Type check
mypy paper_toolkit_mcpMIT
Clear all cached search results.
Returns: Dict with number of cleared entries.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses the destructive action (clear) and return type, but lacks details on scope (e.g., user vs global), side effects, or idempotency. No annotations provided to supplement.
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?
Extremely concise (two sentences), front-loaded with purpose, and no extraneous information. Every word 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?
Adequate for a simple tool with no parameters and no output schema complexities. Could mention idempotency or scope, but overall sufficient.
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?
No parameters, so schema coverage is 100%. Description adds meaning by explaining the action and return value, meeting the baseline for zero-param tools.
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?
Describes a specific verb (clear) and resource (cached search results), clearly distinguishing from sibling tools like search_papers or library_search.
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 on when to use this tool or alternatives. Does not specify prerequisites or conditions for clearing cache.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Download a paper's PDF using its cite_key.
Looks up the paper in the local library by cite_key, checks for an existing local PDF, then falls back to download_paper.
Args: cite_key: The paper's cite_key (e.g. 'Kxq') from search results. save_path: Directory to save the PDF (default: /downloads). Returns: Path to the downloaded PDF, or an error message.
| Name | Required | Description | Default |
|---|---|---|---|
| cite_key | Yes | ||
| save_path | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the lookup, local check, and fallback behavior. However, it does not specify file overwrite policy or error handling for missing papers.
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 well-structured with a clear opening and bullet-pointed Args/Returns. It is slightly verbose but every sentence adds value. It could be more concise by removing the parameter descriptions that could be in schema.
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 complexity (2 params, no annotations, but an output schema exists), the description fully covers the workflow, parameters, and return value. It references sibling tool download_paper, providing necessary 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 0%, but the description provides clear explanations for both parameters: cite_key format and source, save_path default directory. This adds significant value beyond the schema titles.
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 downloads a paper PDF using a cite_key. It distinguishes itself from the sibling 'download_paper' by explaining that it checks for an existing local PDF first and falls back to download_paper, making the purpose and workflow explicit.
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 implies when to use: when you have a cite_key from search results. It mentions a fallback to download_paper, hinting at an alternative. However, it does not explicitly state when NOT to use or provide a direct comparison with download_paper.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Try source-native download, OA repositories, Unpaywall, then optional Sci-Hub.
Args: source: Source name (arxiv, medrxiv, semantic, crossref, pubmed, pmc, dblp, openalex). paper_id: Source-native paper identifier. doi: Optional DOI used for repository/unpaywall/Sci-Hub fallback. title: Optional title used for repository/Sci-Hub fallback when DOI is unavailable. save_path: Directory to save downloaded files. use_scihub: Whether to fallback to Sci-Hub after OA attempts fail. scihub_base_url: Sci-Hub mirror URL for fallback. Returns: Download path on success or explanatory error message.
| Name | Required | Description | Default |
|---|---|---|---|
| doi | No | ||
| title | No | ||
| source | Yes | ||
| paper_id | Yes | ||
| save_path | No | ||
| use_scihub | No | ||
| scihub_base_url | No | https://sci-hub.se |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses the multi-source fallback, optional Sci-Hub, and the return value (path or error). It could add details on error types or side effects (e.g., file writing).
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?
Well-structured with Args and Returns sections, front-loaded with the core purpose. Slightly verbose but each sentence is informative; no 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?
Given the tool has 7 parameters and no annotations, the description covers purpose, parameters, and return. It mentions the output is a path or error, which aligns with the output schema. Missing guidance on prerequisites or potential side effects like overwriting files.
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 0%, but the description adds meaning for all 7 parameters: it explains that doi/title are optional fallback keys, save_path is a directory, use_scihub enables a fallback, and scihub_base_url sets the mirror. This fully compensates for the lack of schema descriptions.
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 specifically states 'Try source-native download, OA repositories, Unpaywall, then optional Sci-Hub', providing a clear verb+resource with a defined fallback chain. This distinguishes it from siblings like 'download_by_cite_key' which uses a different identifier.
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 explains the fallback strategy and parameter roles (e.g., doi/title for fallback) but does not explicitly state when not to use this tool or mention alternatives. It implies a broad downloading use case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get paper metadata by DOI with multi-source fallback.
Tries CrossRef first (richest metadata), then Semantic Scholar (best abstract coverage) to backfill missing abstract. Only saves to local library when an abstract is available.
Args: doi: Digital Object Identifier (e.g., '10.1038/nature12373'). Returns: Paper metadata dict. Empty dict if not found at all.
| Name | Required | Description | Default |
|---|---|---|---|
| doi | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, the description discloses the fallback order (CrossRef then Semantic Scholar) and the condition for saving to library (only if abstract available). This provides adequate transparency for a simple metadata lookup 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 concise, with a clear two-sentence overview followed by structured Args/Returns. No unnecessary repetition. Could be slightly more structured, but it's effective.
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 single parameter and no output schema, the description covers the key behaviors: what the tool does, how it resolves DOIs, and return format. It omits edge cases like multiple DOIs or errors, but it's sufficient for basic 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?
The description adds meaning to the 'doi' parameter with an example and explanation of its format, which is not present in the input schema (just 'string'). Since schema coverage is 0%, this additional context is valuable.
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 fetches paper metadata by DOI, includes multi-source fallback strategy, and distinguishes from siblings like `search_papers` (search-based) and `download_by_cite_key` (uses cite key). The verb 'Get' and resource 'paper metadata by DOI' are specific.
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 explains the fallback logic and saving condition, implying when this tool is appropriate (when DOI is known). It does not explicitly state when NOT to use it or mention alternatives, but the context is clear enough for an agent to decide.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Initialize harness infrastructure for academic paper writing.
Creates the following structure in the project directory:
CLAUDE.md: Project map for AI Agent (in project root)
.harness/: Harness directory containing:
rules.md: Writing rules (R0-R9)
verify.py: Automated verification script
checks/: Verification rule implementations
specs/manuscript-spec.yaml: Configurable standards
checklist.md: Manual review checklist
Harness.md: Usage guide
Args: project_dir: Target project directory path. Defaults to current working directory. force: If True, overwrite existing .harness/ directory. Defaults to False.
Returns: JSON string with initialization status and next steps.
| Name | Required | Description | Default |
|---|---|---|---|
| force | No | ||
| project_dir | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
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 that files are created in the project directory and that force overwrites existing .harness/. This is sufficient, though it could mention any potential side effects or permissions needed.
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 well-structured with a summary, then a bullet list of created files, then Args. It is front-loaded and each sentence adds value, though it could be slightly more concise.
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?
The description covers the tool's purpose, created artifacts, parameters, and return value. Given the presence of an output schema and the tool's simplicity (init with only creation side effects), it is complete enough for correct 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?
With 0% schema description coverage, the description compensates by detailing both parameters: project_dir (path, default) and force (overwrite behavior). This adds meaning beyond the schema's defaults and titles.
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 uses a specific verb ('Initialize') and clearly identifies the resource ('harness infrastructure for academic paper writing'). It lists the created files and structure, which distinguishes it from siblings like harness_list_rules and harness_verify.
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 does not explicitly state when to use this tool versus its siblings. While it is implied to be the first step before harness_verify, there is no direct guidance on prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all harness rules with their descriptions.
Returns a summary of all verification rules (R0-R9) including rule ID, name, severity, and brief description.
Returns: JSON string with list of all rules.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It implies a read-only operation but does not explicitly state it is non-destructive or safe. Adequate but lacks explicit behavioral disclosure.
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 efficient, with a clear first sentence and a Returns section. Minor redundancy in the second paragraph could be trimmed.
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?
Despite no annotations, the description fully explains the return value format and content (JSON string with details). Enough for an agent to understand output without relying on output schema.
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 zero parameters and 100% schema coverage, the description adds full meaning by specifying the return content (rule ID, name, severity, description) and format (JSON string).
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 lists all harness rules with their descriptions, using specific verb 'list' and resource 'harness rules'. It distinguishes from siblings like 'harness_verify' which runs verification, not listing.
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 on when to use this tool versus alternatives (e.g., harness_verify). No explicit context or exclusions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Verify a manuscript against harness rules.
Runs the harness verification script on the specified manuscript file and returns a JSON report of violations, warnings, and info messages.
Args: manuscript_path: Path to the manuscript markdown file. verbose: If True, include detailed violation information. Defaults to False.
Returns: JSON string with verification results including error count, warning count, and detailed violation information.
| Name | Required | Description | Default |
|---|---|---|---|
| verbose | No | ||
| manuscript_path | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided. The description indicates it returns a report but does not explicitly state that it is read-only or has no side effects. It also does not mention authentication requirements or rate limits.
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, well-structured with Args and Returns sections, and every sentence adds value. No redundant 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?
Given that there is an output schema, the description adequately explains return values (JSON with error count, warning count, details). The two parameters are well covered. Minor missing: no examples or edge cases.
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 0% schema description coverage, the description compensates well by explaining each parameter: manuscript_path as a path to markdown file and verbose as a boolean defaulting to False with its effect. This adds meaning beyond the raw schema.
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?
Description explicitly states the tool verifies a manuscript against harness rules and returns a JSON report. This clearly distinguishes it from sibling tools like harness_init (initializes) and harness_list_rules (lists rules), as it focuses on verification.
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 does not provide guidance on when to use this tool versus alternatives like harness_init or harness_list_rules. It only states the basic purpose but lacks contextual cues for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the local paper library (SQLite) by keyword.
Searches across title, authors, and abstract of all previously fetched papers. This is an offline operation — no network calls are made.
Args: keyword: Search keyword (matched against title/authors/abstract). limit: Maximum number of results to return (default: 50). Returns: List of matching paper records from the local library.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| keyword | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
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 accurately describes the search scope (title, authors, abstract) and the offline nature. It does not mention pagination or performance, but for a simple search tool, this is adequate.
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 compact, with a clear one-sentence purpose, followed by structured Args and Returns sections. Every sentence is informative and 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 the tool has an output schema (indicated in context signals) and two simple parameters, the description provides all necessary context. It explains the search fields, offline nature, and return type.
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 descriptions are empty (0% coverage), but the description fully explains both parameters: 'keyword' is matched against title/authors/abstract, and 'limit' controls maximum results (default 50). This adds significant meaning beyond the raw schema.
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 the local paper library by keyword across title, authors, and abstract. It uses a specific verb ('search') and resource ('local paper library'), and distinguishes from siblings like 'search_papers' by emphasizing it's an offline operation.
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 explicitly notes this is an offline operation with no network calls, guiding users to choose this tool over online search alternatives. While it doesn't explicitly list when not to use, the context provided is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get statistics about the local paper library.
Returns: Dict with total paper count, counts by source, PDF/fulltext coverage, and the database file path.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full burden. It discloses the return structure but does not explicitly state that the tool is read-only or safe, nor any potential side effects. Given the nature of a stats tool, it is likely safe, but the description lacks this explicit assurance.
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 extremely concise, using two short sentences. The first states the purpose, the second lists the return fields. No extraneous words, well-structured.
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 simplicity (no parameters, read-only stats), the description is fairly complete. It lists the return fields and implies non-destructive behavior. However, it could mention whether the stats reflect a snapshot or are live, and if any performance impact exists. Minor gaps.
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?
Tool has zero parameters, so schema coverage is 100%. The description adds no parameter information, which is acceptable since none are needed. Baseline score of 4 is appropriate for a parameterless tool.
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 gets statistics about the local paper library, listing the specific fields returned. It is distinct from sibling tools like library_search or search_papers, which focus on querying papers rather than aggregate stats.
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 implies usage for statistics, but provides no explicit guidance on when to use this tool vs alternatives, nor any prerequisites or conditions. The agent must infer its role from the tool name and purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Download and extract full text from a paper using its cite_key.
Checks for cached full text first, then downloads the PDF and extracts text via pypdf. The extracted text is cached in the local library.
Args: cite_key: The paper's cite_key (e.g. 'Kxq') from search results. save_path: Directory for PDF download (default: /downloads). Returns: The extracted text content, or an error message.
| Name | Required | Description | Default |
|---|---|---|---|
| cite_key | Yes | ||
| save_path | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses caching, extraction via pypdf, default save path, and return type. However, it does not explicitly mention network usage or potential side effects beyond caching, but overall it provides good behavioral context.
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 well-structured, with a clear summary followed by details on parameters and return value. Every sentence adds value without redundancy, and the main action is front-loaded.
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 moderate complexity and presence of an output schema (though not shown), the description covers the essential workflow of caching, downloading, and extracting. It mentions error return but could be more explicit about what happens on missing cite_key. Overall, it is sufficiently complete for an agent to 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 0%, so the description must compensate. It adequately explains both parameters: cite_key as from search results with an example, and save_path with default location. This adds meaningful context beyond the schema's titles.
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 downloads and extracts full text using a cite_key, distinguishing it from sibling 'download_by_cite_key' which likely only downloads the PDF. The caching behavior is also mentioned, providing a specific verb-resource pair.
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 does not explicitly specify when to use this tool versus alternatives like 'download_by_cite_key' or 'get_paper_by_doi'. While the caching and extraction behavior is implied, there is no guidance on when not to use it or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Unified top-level search across all configured academic platforms.
Returns only cite_key + title + abstract + year + source for each paper. Papers without abstract are discarded. Defaults to last 5 years.
Args: query: Search query string. max_results_per_source: Max results to fetch from each selected source. sources: Source names, preset group, or 'all'. Groups: medical (pubmed,pmc,medrxiv), cs (arxiv,dblp,semantic), metadata (crossref,openalex). Or comma-separated individual names. year_from: Earliest publication year (default: current year - 5). Pass 0 to disable year filtering. year_to: Latest publication year (default: none). Returns: Aggregated dict with per-source stats, errors, and simplified papers.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| sources | No | all | |
| year_to | No | ||
| year_from | No | ||
| max_results_per_source | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
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 that papers without abstracts are discarded, the default year range, and the return format (aggregated dict with stats and errors). However, it does not explicitly state that this is a read-only operation or mention rate limits or authentication.
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 well-structured with a clear purpose statement, return format note, and a separate 'Args' section. It is concise, using only necessary sentences with no redundant 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?
Given the tool has 5 parameters, no annotations, and an output schema, the description covers key behaviors (discarding abstracts, defaults) and return format. It could mention duplicate handling or limit details, but it is largely sufficient for an agent.
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 coverage is 0%, so the description must fully explain parameters. The 'Args' section adds significant value by describing each parameter, including default values, source groups (e.g., 'medical', 'cs'), and how to disable year filtering. This goes well beyond the schema's type and default fields.
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 'Unified top-level search across all configured academic platforms' and lists the specific return fields (cite_key, title, abstract, year, source). It distinguishes from siblings like library_search by being top-level and cross-platform.
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 explicit parameter details including default values, source groups, and year filtering behavior. It does not explicitly state when not to use this tool versus alternatives, but the purpose and parameter details guide appropriate use.
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.3.0cache_clear4 fields changedOutput schema / additionalPropertiesAdded value: +trueOutput schema / propertiesRemoved value: -{
- "result": {
- "additionalProperties": true,
- "title": "Result",
- "type": "object"
- }
-}Output schema / requiredRemoved value: -[
- "result"
-]Output schema / titlePrevious value: -"cache_clearOutput"New value: +"cache_clearDictOutput"cache_listdownload_arxivdownload_basedownload_biorxivdownload_by_cite_keydownload_citeseerxdownload_crossrefdownload_dblpdownload_doajdownload_haldownload_iacrdownload_medrxivdownload_openairedownload_openalexdownload_paperdownload_pubmeddownload_scihubdownload_semanticdownload_ssrndownload_with_fallbackdownload_zenodoexport_referencesget_crossref_paper_by_doiget_paper_by_doiget_paper_metadataharness_initharness_list_rulesharness_verifylibrary_searchlibrary_statsprocess_manuscriptread_arxiv_paperread_base_paperread_biorxiv_paperread_by_cite_keyread_citeseerx_paperread_crossref_paperread_dblp_paperread_doaj_paperread_hal_paperread_iacr_paperread_medrxiv_paperread_openaire_paperread_openalex_paperread_pubmed_paperread_semantic_paperread_ssrn_paperread_zenodo_papersearch_arxivsearch_basesearch_biorxivsearch_citeseerxsearch_coresearch_crossrefsearch_dblpsearch_doajsearch_europepmcsearch_google_scholarsearch_halsearch_iacrsearch_medrxivsearch_openairesearch_openalexsearch_papers7 fields changedInput schema / properties / yearRemoved value: -{
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "title": "Year"
-}Input schema / properties / year_fromAdded value: +{
+ "anyOf": [
+ {
+ "type": "integer"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "title": "Year From"
+}Input schema / properties / year_toAdded value: +{
+ "anyOf": [
+ {
+ "type": "integer"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "title": "Year To"
+}Output schema / additionalPropertiesAdded value: +trueOutput schema / propertiesRemoved value: -{
- "result": {
- "additionalProperties": true,
- "title": "Result",
- "type": "object"
- }
-}Output schema / requiredRemoved value: -[
- "result"
-]Output schema / titlePrevious value: -"search_papersOutput"New value: +"search_papersDictOutput"search_pmcsearch_pubmedsearch_semanticsearch_ssrnsearch_unpaywallsearch_zenodov0.2.0cache_clearcache_listdownload_arxivdownload_basedownload_biorxivdownload_citeseerxdownload_crossrefdownload_dblpdownload_doajdownload_haldownload_iacrdownload_medrxivdownload_openairedownload_openalexdownload_pubmeddownload_scihubdownload_semanticdownload_ssrndownload_with_fallbackdownload_zenodoexport_referencesget_crossref_paper_by_doiget_paper_metadataprocess_manuscriptread_arxiv_paperread_base_paperread_biorxiv_paperread_citeseerx_paperread_crossref_paperread_dblp_paperread_doaj_paperread_hal_paperread_iacr_paperread_medrxiv_paperread_openaire_paperread_openalex_paperread_pubmed_paperread_semantic_paperread_ssrn_paperread_zenodo_papersearch_arxivsearch_basesearch_biorxivsearch_citeseerxsearch_coresearch_crossrefsearch_dblpsearch_doajsearch_europepmcsearch_google_scholarsearch_halsearch_iacrsearch_medrxivsearch_openairesearch_openalexsearch_paperssearch_pmcsearch_pubmedsearch_semanticsearch_ssrnsearch_unpaywallsearch_zenodoEach tool serves a clearly distinct purpose: searching, metadata retrieval, downloading, reading, local library management, and manuscript verification. Overlaps like download_by_cite_key and download_paper have different input methods (cite_key vs source+id), making them unambiguous.
All tools follow a consistent verb_noun pattern in snake_case. The harness tools share a uniform prefix, while the rest use clear action nouns (e.g., download_paper, library_search). No mixing of conventions.
With 11 tools, the set is well-scoped for an academic paper toolkit covering search, retrieval, local library, and manuscript verification. Neither sparse nor bloated.
Core workflows (search, metadata, download, read, local library) are covered. Minor gaps include no manual paper addition, no library entry editing/deletion, and no citation export, but these are not critical for typical usage.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Academic research MCP server for paper search, citation checks, graphs, and deep research.
Auditable MCP server for PubMed, Europe PMC, ClinicalTrials.gov, and bioRxiv/medRxiv queries
MCP server for Altmetric APIs - track research attention across news, policy, social media, and more
Multi-engine scholarly research server for search, traversal, full text, and reading lists.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/czwziy/paper-toolkit-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
