pubmed-clinical-mcp
Provides tools for searching PubMed/MEDLINE, fetching article metadata, retrieving full text from PubMed Central, checking full-text availability via Unpaywall, finding related articles, building clinical queries, extracting PICO, and summarizing evidence.
Click on "Deploy 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., "@pubmed-clinical-mcpsearch for diabetic foot ulcer classification evidence"
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.
PubMed Clinical MCP
pubmed-clinical-mcp is a lightweight Model Context Protocol (MCP) server for clinical biomedical literature retrieval. It gives MCP-compatible clients reusable tools for PubMed/MEDLINE search, article metadata retrieval, PubMed Central full text, full-text availability checks, related articles, clinical query building, PICO extraction, article ranking, and evidence summarization.
This project is designed for clinical evidence support and research workflows. It is not a diagnosis system, treatment recommendation system, paywall bypasser, or institutional-library automation tool.
Why This Exists
Many medical agents need reliable access to public biomedical literature, but PubMed handling often gets mixed into one-off application code. This package separates that capability into a standalone MCP server so tools like Codex, Claude Desktop, Cursor, or other MCP clients can call PubMed-focused tools directly.
Related MCP server: PubMed MCP Server
Features
PubMed/MEDLINE search through NCBI E-utilities.
PubMed article fetching with title, abstract, authors, journal, year, DOI, PMCID, MeSH terms, publication types, and URL.
PubMed Central open-access full-text section retrieval when legally available.
Related PubMed article lookup through NCBI
elink.Unpaywall DOI availability checks for legal open-access links.
Clinical query builder for natural-language medical questions.
Article ranking against a clinical question with relevance reasons.
Rough PICO extraction from abstracts or article passages.
Citation-backed evidence table and limitations summary.
Retry/backoff on
429and transient server failures.Optional local JSON cache.
Tests use local fixtures, so CI does not need live API access.
Tool List
Tool | Purpose |
| Convert a natural-language clinical question into a PubMed-ready query. |
| Search PubMed and return PMIDs plus lightweight metadata. |
| Fetch detailed PubMed article metadata for PMIDs. |
| Build a query, search, fetch, rank, and return citations in one call. |
| Fetch PMC full-text sections when a PMCID is legally available. |
| Check PMC and Unpaywall for legal full-text access. |
| Find related PubMed articles using NCBI |
| Rank article objects against a clinical question. |
| Extract rough population/intervention/comparator/outcome fields. |
| Produce an evidence table, citation-backed findings, and limitations. |
Install
git clone https://github.com/jxia622/pubmed-clinical-mcp.git
cd pubmed-clinical-mcp
python3 -m venv .venv
source .venv/bin/activate
pip install -e .Optional Environment Variables
No paid keys are required. For low-volume demos, the server can run without API keys.
export NCBI_EMAIL="you@example.com"
export NCBI_API_KEY="optional_free_ncbi_key"
export UNPAYWALL_EMAIL="you@example.com"
export PUBMED_MCP_CACHE_PATH=".cache/pubmed_clinical_mcp.json"Notes:
NCBI_EMAILis recommended for NCBI E-utilities usage.NCBI_API_KEYis optional and raises NCBI rate limits.UNPAYWALL_EMAILis required for Unpaywall checks.PUBMED_MCP_CACHE_PATHenables a simple local JSON cache.
Run The MCP Server
pubmed-clinical-mcpor:
python -m pubmed_clinical_mcp.serverExample MCP Client Config
{
"mcpServers": {
"pubmed-clinical": {
"command": "python",
"args": ["-m", "pubmed_clinical_mcp.server"],
"env": {
"NCBI_EMAIL": "you@example.com",
"PUBMED_MCP_CACHE_PATH": ".cache/pubmed_clinical_mcp.json"
}
}
}
}Example Tool Calls
Build a PubMed query
{
"natural_language_question": "Why might a diabetic foot ulcer be Wagner grade 2 instead of grade 1?",
"filters": {
"english_only": true,
"year_from": 2020
}
}Example output:
{
"query": "(\"diabetic foot\"[Title/Abstract] OR \"diabetic foot ulcer\"[Title/Abstract]) AND (Wagner[Title/Abstract] OR classification[Title/Abstract] OR staging[Title/Abstract]) AND english[Language] AND (\"2020\"[Date - Publication] : \"3000\"[Date - Publication])",
"explanation": [
"Mapped diabetic foot ulcer + Wagner wording to title/abstract terms for classification and staging."
],
"filters": {
"english_only": true,
"year_from": 2020
}
}Search and fetch ranked PubMed articles
{
"clinical_question": "What evidence supports using wound depth in diabetic foot ulcer severity assessment?",
"filters": {
"english_only": true
},
"max_results": 10
}Returns:
query_usedquery_explanationranked_articlescitations
Fetch PMC full text
{
"pmcid": "PMC9446755"
}Returns parsed sections when the article is available in PubMed Central.
Architecture
flowchart LR
Client["MCP client"] --> Server["pubmed-clinical-mcp server"]
Server --> Query["clinical query builder"]
Server --> PubMed["NCBI PubMed E-utilities"]
Server --> PMC["PubMed Central XML"]
Server --> Unpaywall["Unpaywall API"]
Server --> Rank["ranking + PICO + summarization helpers"]
Server --> Cache["optional JSON cache"]Core modules:
src/pubmed_clinical_mcp/
server.py # MCP tool definitions
sources/pubmed.py # PubMed esearch, efetch, elink
sources/pmc.py # PMC full-text XML parsing
sources/unpaywall.py # DOI open-access checks
clinical/query_builder.py # natural language -> PubMed query
clinical/ranking.py # relevance ranking
clinical/pico.py # rough PICO extraction
clinical/summarizer.py # evidence table + limitationsDevelopment
Tests use fixtures and do not call live APIs:
PYTHONPATH=src python3 -m unittest discover -s testsCompile check:
PYTHONPATH=src python3 -m compileall src testsAPI And Rate-Limit Notes
PubMed and PMC use NCBI E-utilities.
NCBI allows higher request rates when
NCBI_API_KEYis configured.The server includes basic retry/backoff for
429and transient5xxfailures.The cache is intentionally simple and optional. It is not a vector database.
Safety And Scope
This server:
retrieves public biomedical literature metadata and legal open-access text;
does not diagnose;
does not prescribe treatment;
does not bypass paywalls;
does not scrape publisher websites;
does not automate university or hospital library login;
does not store institutional credentials.
Any clinical interpretation should be performed by qualified clinicians using the retrieved sources and appropriate guidelines.
Available Tools
10 toolsbuild_clinical_queryB
Convert a natural-language clinical question into a PubMed-ready query.
| Name | Required | Description | Default |
|---|---|---|---|
| filters | No | ||
| natural_language_question | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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 only states 'convert' but does not disclose whether it calls an external API, has rate limits, or requires authentication. The description is minimal and lacks 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 a single sentence with no wasted words, but it is too short for a tool with two parameters and potential complexity. It sacrifices necessary detail for brevity.
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 role in a clinical query pipeline, the description lacks sufficient context about input parameters, output format (though output schema exists), and how it fits with sibling tools. It is not complete enough for an agent to reliably invoke it.
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 does not mention either of the two parameters. With 0% schema description coverage, the description should compensate but does not. The 'filters' parameter is unexplained, and 'natural_language_question' is only implied by the main sentence.
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 converts a natural-language clinical question into a PubMed-ready query, specifying both the action (convert) and the domain (clinical question to query). It distinguishes from sibling tools which perform search, retrieval, or summarization.
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 explicit guidance on when to use this tool versus alternatives like search_pubmed. The description implies it is a preprocessing step but does not state it should be used before search tools. There is no mention of when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_full_text_availabilityC
Check PMC and Unpaywall for legal full-text availability.
| Name | Required | Description | Default |
|---|---|---|---|
| doi | No | ||
| pmid | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description should disclose behavioral traits. It only states the sources checked but does not reveal what happens on failure, API dependencies, rate limits, or side effects. The behavior is opaque.
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 one short sentence (7 words) but omits essential information, making it under-specified rather than concise. It lacks structure and earns its place poorly.
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 two optional parameters and an output schema, the description does not clarify that a identifier must be provided or what the scope of 'availability' means. Incomplete for 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 coverage is 0% and the description does not mention the parameters (doi, pmid) at all. It fails to explain that at least one is needed or their required formats, leaving the agent without guidance.
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 checks PMC and Unpaywall for legal full-text availability, specifying the sources and action. It distinguishes from siblings like fetch_pmc_full_text and 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 does not provide any guidance on when to use this tool versus alternatives (e.g., when to check availability vs. directly fetching full text). No when-not-to-use or context distinctions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
extract_picoB
Extract a rough PICO structure from an abstract or article passage.
| Name | Required | Description | Default |
|---|---|---|---|
| article_text_or_abstract | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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 only notes that the extraction is 'rough' but offers no details on error handling, input validation, or output behavior beyond what the output schema might provide.
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 of 12 words directly conveys the tool's purpose without any extraneous information. It is perfectly front-loaded and 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?
Given the existence of an output schema, return values are covered. However, the description lacks context on when this tool should be preferred over siblings like build_clinical_query, and omits any prerequisites or limitations.
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 adds some meaning by specifying the input is 'from an abstract or article passage', clarifying the parameter's domain. However, it does not detail format expectations or constraints.
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 states 'Extract a rough PICO structure from an abstract or article passage', which is a specific verb (Extract) and clear resource (PICO structure). This clearly distinguishes it from siblings like search_pubmed, fetch_pubmed_articles, and summarize_evidence.
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 such as build_clinical_query or summarize_evidence. The description lacks any when-to-use or when-not-to-use context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
fetch_pmc_full_textB
Fetch legal PubMed Central full-text sections when a PMCID is available.
| Name | Required | Description | Default |
|---|---|---|---|
| pmid | No | ||
| pmcid | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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 fails to mention what happens if both pmid and pmcid are provided, if none are provided, or any authentication or rate limits. The term 'legal' hints at compliance but is vague.
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, front-loaded sentence with no waste. It earns its place by stating the core action and condition, though it could be slightly expanded without harming conciseness.
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 two optional params with no schema descriptions, no annotations, and an output schema that may cover return values, the description is too brief. It fails to explain parameter interaction or fallback behavior, leaving critical gaps 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 should explain parameter usage. It only implies pmcid is preferred but does not clarify the role of pmid, whether they are interchangeable, or what happens when both are provided.
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 ('Fetch') and resource ('legal PubMed Central full-text sections'), clearly distinguishing it from siblings like check_full_text_availability or fetch_pubmed_articles. The condition 'when a PMCID is available' clarifies scope.
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 when a PMCID is available but does not explicitly state when not to use it, nor does it mention alternatives like check_full_text_availability for availability checks or fetch_pubmed_articles for non-PMC content.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
fetch_pubmed_articlesC
Fetch PubMed title, abstract, authors, journal, year, DOI, MeSH, and publication types.
| Name | Required | Description | Default |
|---|---|---|---|
| pmids | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must cover behavioral traits. It only lists fields retrieved and omits important details such as required authentication, handling of invalid PMIDs, or return format.
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 lists the fetched fields. It is concise but could be improved by front-loading the verb and input specification.
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 presence of an output schema and siblings, the description is incomplete. It fails to specify that the tool returns metadata only, how many PMIDs can be processed, or the order of results. The missing details hinder 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?
The parameter 'pmids' has 0% schema description coverage, and the tool description provides no explanation of its purpose, format, or constraints. The agent receives no guidance on what values to supply.
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 specifies the verb 'fetch' and the resource 'PubMed articles' and lists specific fields retrieved. However, it does not explicitly mention that the input is a list of PMIDs, which is important for clarity.
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 siblings like search_pubmed or fetch_pmc_full_text. The description lacks context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
rank_articlesA
Rank article summaries against a clinical question and explain relevance.
| Name | Required | Description | Default |
|---|---|---|---|
| articles | Yes | ||
| clinical_question | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It accurately indicates a stateless computation (ranking and explaining), which suggests no side effects. However, it does not detail return format or potential limitations, but the core behavior is clear.
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 conveys the essential purpose without unnecessary detail. 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?
Given the tool has an output schema (not shown) and two parameters, the description is minimal. It lacks details on ranking criteria, explanation format, or any usage prerequisites. It is adequate but not comprehensive.
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 0% description coverage, and the description adds no further meaning beyond the parameter names. It does not specify required properties for the 'articles' objects or constraints on 'clinical_question', leaving significant ambiguity for an agent.
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 (rank), the resource (article summaries), the context (against a clinical question), and the output (explain relevance). It effectively distinguishes from sibling tools like search_pubmed or summarize_evidence, which have different 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 implies the tool is used when you have articles to rank, but it does not explicitly state when to use it versus alternatives, nor provide any when-not-to-use guidance. The usage context is implied but not elaborated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_and_fetch_pubmedC
Build a clinical PubMed query, search PubMed, fetch articles, and return ranked summaries.
| Name | Required | Description | Default |
|---|---|---|---|
| filters | No | ||
| max_results | No | ||
| clinical_question | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only says it returns ranked summaries, but omits details like ranking algorithm, potential rate limits, or error handling (e.g., empty results).
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 concise sentence, but it is too brief. It lacks structure such as separate sections for purpose, usage, and parameters. While not verbose, it is under-specified.
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 tool combines multiple sub-tasks and has an output schema, but the description does not explain the output format or ranking criteria. It is incomplete given the tool's complexity.
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%. The description does not add any meaning to parameters 'clinical_question', 'filters', or 'max_results' beyond their names. This is insufficient for a tool with three parameters.
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 function: building a query, searching PubMed, fetching articles, and returning ranked summaries. It distinguishes from simpler siblings like 'search_pubmed' (just search) and 'fetch_pubmed_articles' (just fetch).
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 like 'build_clinical_query' or 'rank_articles'. The description implies it combines steps, but does not explicitly state that it should be used when all steps are needed, nor does it mention limitations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_pubmedB
Search PubMed and return PMIDs plus a lightweight metadata summary.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| filters | No | ||
| max_results | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It discloses the return format (PMIDs and metadata summary) but does not mention rate limits, authentication needs, pagination, or what happens with empty results.
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, efficient sentence with no extraneous words. Front-loaded with the verb and resource.
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 having an output schema, the description is too brief for a tool with 3 parameters and 0% schema coverage. It lacks parameter explanations and contextual details (e.g., search behavior with filters).
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 0% description coverage, and the tool description does not explain any parameters (e.g., what 'filters' or 'max_results' mean). The agent receives no semantic guidance beyond parameter names.
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 action ('Search PubMed') and its output ('return PMIDs plus a lightweight metadata summary'). It distinguishes this search tool from sibling tools that fetch full text or find related articles.
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 fetch_pubmed_articles or find_related_articles. No context 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.
summarize_evidenceC
Summarize article evidence into a table, limitations, and citation-backed findings.
| Name | Required | Description | Default |
|---|---|---|---|
| articles | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description does not disclose behavioral traits such as whether the tool is read-only, requires authentication, or has any side effects. The description only states the output format, not the 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 a single, concise sentence with minimal waste. However, it is too brief to provide sufficient context, achieving conciseness at the expense of informativeness.
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 and the presence of an output schema, the description partially covers output format but lacks input specification, usage guidance, and behavioral details. It is incomplete for safe and correct agent 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 single 'articles' parameter is described only by the tool name and description, with no details on required properties or structure. Schema coverage is 0%, and the description fails to specify what fields the article objects should contain, leaving the agent uncertain.
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 summarizes article evidence into a table, limitations, and citation-backed findings. This clearly distinguishes it from siblings like extract_pico or rank_articles, which have different 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?
No guidance on when to use this tool versus alternatives such as extract_pico or search_pubmed. The description lacks any context about prerequisites or conditions for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
10 tool updates
v0.1.0- First observed
build_clinical_query - First observed
check_full_text_availability - First observed
extract_pico - First observed
fetch_pmc_full_text - First observed
fetch_pubmed_articles - First observed
find_related_articles - First observed
rank_articles - First observed
search_and_fetch_pubmed - First observed
search_pubmed - First observed
summarize_evidence
TDQS
Scored across 10 tools
Each tool has a clearly distinct purpose: building queries, checking availability, extracting PICO, fetching full text, fetching articles, finding related articles, ranking, searching (with and without full pipeline), and summarizing. No ambiguity.
All tool names follow a consistent verb_noun pattern in snake_case (e.g., build_clinical_query, fetch_pubmed_articles, summarize_evidence). No deviations or mixed conventions.
10 tools is well-scoped for a clinical PubMed assistant. Each tool serves a distinct step in the research workflow without unnecessary overlap or missing critical functionality.
The tool set covers the full clinical evidence retrieval workflow: natural language query conversion, search, article fetch, full text retrieval, PICO extraction, ranking, summarization, and related article discovery. No obvious gaps.
Maintenance
Related MCP Connectors
Auditable MCP server for PubMed, Europe PMC, ClinicalTrials.gov, and bioRxiv/medRxiv queries
PubMed MCP — wraps the NCBI E-utilities API (biomedical literature, free, no auth)
Bioinformatics MCP for genomic variant interpretation, gene-disease evidence and literature.
MCP gateway federating 22 biomedical MCP servers behind one endpoint: gnomAD, ClinVar, HPO, VEP.
Related MCP Servers
- AlicenseAqualityCmaintenanceAn MCP server that provides access to PubMed articles through the Entrez API.275 PyPI171MIT
- -licenseNot gradedqualityNot gradedmaintenanceAn MCP server implementation that enables searching and retrieving research articles from PubMed with specific focus on open access content filtering and full-text link retrieval.8 npm3-
- AlicenseNot gradedqualityFmaintenanceMCP server for PubMed search and literature summarization52MIT
- AlicenseAqualityDmaintenance轻量级MCP服务器,提供学术文献检索、论文详情、全文下载等功能,可配合PubMed MCP用于生物医学检索链路。878 npm2ISC