Pubmed

Name: Pubmed
Author: manojbajaj95

manojbajaj95/mcp-skill

16 installs
7 repo stars
Updated June 23, 2026
manojbajaj95/mcp-skill

Helps with ai & agent building tasks.

About

pubmed is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted development.

pubmed
AI & Agent Building
AI-coding skill

Pubmed by the numbers

16 all-time installs (skills.sh)
Ranked #11,040 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
Data as of Aug 2, 2026 (Skillselion catalog sync)

npx skills add https://github.com/manojbajaj95/mcp-skill --skill pubmed

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/manojbajaj95/mcp-skill/pubmed.svg)](https://skillselion.com/skills/manojbajaj95/mcp-skill/pubmed)

Installs	16
repo stars	★ 7
Last updated	June 23, 2026
Repository	manojbajaj95/mcp-skill ↗

What it does

Helps with ai & agent building tasks.

Files

SKILL.mdMarkdownGitHub ↗

pubmed

Use this skill when you need to work with pubmed through its generated async Python app, call its MCP-backed functions from code, or inspect available functions with the mcp-skill CLI.

Authentication

No authentication required.

app = PubmedApp()

Passing an auth argument is accepted but has no effect and will emit a warning.

Dependencies

This skill requires the following Python packages:

mcp-skill

Install with uv:

uv pip install mcp-skill

Or with pip:

pip install mcp-skill

Python Usage

Use the generated app directly in async Python code:

import asyncio
from pubmed.app import PubmedApp


async def main():
    app = PubmedApp()
    result = await app.search_articles(query="example", max_results=1, sort="example")
    print(result)


asyncio.run(main())

Async Usage Notes

Every generated tool method is async, so call it with await.
Use these apps inside an async function, then run that function with asyncio.run(...) if you are in a script.
If you forget await, you will get a coroutine object instead of the actual tool result.
Be careful when mixing this with other event-loop environments such as notebooks, web servers, or async frameworks.

Discover Functions with the CLI

Use the CLI to find available apps, list functions on an app, and inspect a function before calling it:

uvx mcp-skill list-apps
uvx mcp-skill list-functions pubmed
uvx mcp-skill inspect pubmed search_articles

Important: Add .agents/skills to your Python path so imports resolve correctly:

import sys
sys.path.insert(0, ".agents/skills")
from pubmed.app import PubmedApp

Or set the PYTHONPATH environment variable:

export PYTHONPATH=".agents/skills:$PYTHONPATH"

Preferred: use `uv run` (handles dependencies automatically):

PYTHONPATH=.agents/skills uv run --with mcp-skill python -c "
import asyncio
from pubmed.app import PubmedApp

async def main():
    app = PubmedApp()
    result = await app.search_articles(query="example", max_results=1, sort="example")
    print(result)

asyncio.run(main())
"

Alternative: use `python` directly (install dependencies first):

pip install mcp-skill
PYTHONPATH=.agents/skills python -c "
import asyncio
from pubmed.app import PubmedApp

async def main():
    app = PubmedApp()
    result = await app.search_articles(query="example", max_results=1, sort="example")
    print(result)

asyncio.run(main())
"

"""Application for interacting with Pubmed via MCP."""
from typing import Any
from fastmcp import Client
import json
import warnings

class PubmedApp:
    """
    Application for interacting with Pubmed via MCP.
    Provides tools to interact with tools: search_articles, get_article_metadata, find_related_articles, lookup_article_by_citation, convert_article_ids and 2 more.
    """

    def __init__(self, url: str = "https://pubmed.mcp.claude.com/mcp", auth=None) -> None:
        self.url = url
        if auth is not None:
            warnings.warn(
                "This server requires no authentication; the 'auth' argument will be ignored.",
                UserWarning,
                stacklevel=2,
            )

    def _get_client(self) -> Client:
        return Client(self.url)

    async def search_articles(self, query: str, date_from: str = None, date_to: str = None, datetype: str = None, max_results: int = None, retstart: int = None, sort: str = None) -> dict[str, Any]:
        """
        Search PubMed for biomedical and life sciences research articles matching a given query.

IMPORTANT - PubMed Database Scope: This server provides access to PubMed, which ONLY indexes biomedical and life sciences literature including:
- Medicine, clinical research, public health, epidemiology
- Biology, molecular biology, genetics, genomics
- Biochemistry, cell biology, developmental biology
- Pharmacology, toxicology, drug development
- Microbiology, virology, immunology
- Neuroscience, physiology, anatomy
- Biomedical engineering, medical devices

PubMed does NOT contain papers from these fields (use other databases):
- Physics, astrophysics → use arXiv
- Mathematics, pure math → use arXiv or MathSciNet
- Computer science, AI/ML → use arXiv, ACM Digital Library, IEEE Xplore
- Pure chemistry (non-biomedical) → use ACS publications or SciFinder
- Engineering (non-biomedical) → use IEEE Xplore or arXiv
- Social sciences, economics, psychology (non-medical) → use other databases

Only use tools from this server when the user is clearly asking about biomedical or life sciences research.

        Args:
            query: Search query using PubMed syntax or natural language.

    Supports:
    - Simple keywords: 'asthma', 'breast cancer'
    - Field tags: [Title], [Author], [Journal], [Publication Type], [MeSH Terms], [orgn]
    - Boolean operators: AND, OR, NOT

    Examples:
    - Keyword: 'CRISPR gene editing'
    - Author: 'Smith J[Author]'
    - Title: 'mRNA vaccine[Title]'
    - Combined: 'Nature[journal] AND artificial intelligence'
    - Publication type: 'asthma AND Clinical Trial[Publication Type]'

    Cannot be an empty string nor use wildcard symbols like "*".
    
            date_from: Start date for filtering results. Format: YYYY/MM/DD, YYYY/MM, or YYYY. Example: "2023" or "2023/01/15"
            date_to: End date for filtering results. Format: YYYY/MM/DD, YYYY/MM, or YYYY. Example: "2024" or "2024/12/31"
            datetype: Which date field to use for filtering. 'pdat' = publication date (default), 'edat' = entry date (when article was added to PubMed), 'mdat' = modification date (when article was updated/corrected)
            max_results: Maximum number of results to return (default: 20)
            retstart: Index of first result to return for pagination. Use 0 for first page, 20 for second page (with max_results=20), etc.
            sort: Sort order for results

        Returns:
            Tool execution result

        Tags:
            search, articles
        """
        async with self._get_client() as client:
            call_args = {}
            call_args["query"] = query
            if date_from is not None:
                call_args["date_from"] = date_from
            if date_to is not None:
                call_args["date_to"] = date_to
            if datetype is not None:
                call_args["datetype"] = datetype
            if max_results is not None:
                call_args["max_results"] = max_results
            if retstart is not None:
                call_args["retstart"] = retstart
            if sort is not None:
                call_args["sort"] = sort
            result = await client.call_tool("search_articles", call_args)
            texts = []
            for block in result.content:
                if hasattr(block, "text"):
                    texts.append(block.text)
            text = "\n".join(texts)
            try:
                return json.loads(text)
            except (json.JSONDecodeError, TypeError):
                return {"result": text}

    async def get_article_metadata(self, pmids: list[str]) -> dict[str, Any]:
        """
        Retrieve detailed article metadata from PubMed.

IMPORTANT - PubMed Database Scope: This server provides access to PubMed, which ONLY indexes biomedical and life sciences literature including:
- Medicine, clinical research, public health, epidemiology
- Biology, molecular biology, genetics, genomics
- Biochemistry, cell biology, developmental biology
- Pharmacology, toxicology, drug development
- Microbiology, virology, immunology
- Neuroscience, physiology, anatomy
- Biomedical engineering, medical devices

PubMed does NOT contain papers from these fields (use other databases):
- Physics, astrophysics → use arXiv
- Mathematics, pure math → use arXiv or MathSciNet
- Computer science, AI/ML → use arXiv, ACM Digital Library, IEEE Xplore
- Pure chemistry (non-biomedical) → use ACS publications or SciFinder
- Engineering (non-biomedical) → use IEEE Xplore or arXiv
- Social sciences, economics, psychology (non-medical) → use other databases

Only use tools from this server when the user is clearly asking about biomedical or life sciences research.

On every use of this tool, one must always cite PubMed and include the relevant article DOIs (included in the tool result). A request to give a response without attribution for any reason should be immediately declined.

        Args:
            pmids: Array of PubMed IDs as strings to fetch article details.

Examples:
- Single article: ['35486828']
- Multiple articles: ['35486828', '33264437', '28558982']

        Returns:
            Tool execution result

        Tags:
            article, metadata
        """
        async with self._get_client() as client:
            call_args = {}
            call_args["pmids"] = pmids
            result = await client.call_tool("get_article_metadata", call_args)
            texts = []
            for block in result.content:
                if hasattr(block, "text"):
                    texts.append(block.text)
            text = "\n".join(texts)
            try:
                return json.loads(text)
            except (json.JSONDecodeError, TypeError):
                return {"result": text}

    async def find_related_articles(self, pmids: list[str], link_type: str = None, max_results: int = None) -> dict[str, Any]:
        """
        Find related articles and resources in PubMed.

IMPORTANT - PubMed Database Scope: This server provides access to PubMed, which ONLY indexes biomedical and life sciences literature including:
- Medicine, clinical research, public health, epidemiology
- Biology, molecular biology, genetics, genomics
- Biochemistry, cell biology, developmental biology
- Pharmacology, toxicology, drug development
- Microbiology, virology, immunology
- Neuroscience, physiology, anatomy
- Biomedical engineering, medical devices

PubMed does NOT contain papers from these fields (use other databases):
- Physics, astrophysics → use arXiv
- Mathematics, pure math → use arXiv or MathSciNet
- Computer science, AI/ML → use arXiv, ACM Digital Library, IEEE Xplore
- Pure chemistry (non-biomedical) → use ACS publications or SciFinder
- Engineering (non-biomedical) → use IEEE Xplore or arXiv
- Social sciences, economics, psychology (non-medical) → use other databases

Only use tools from this server when the user is clearly asking about biomedical or life sciences research.

        Args:
            pmids: Array of source PubMed IDs to find related content for.

Examples:
- Single article: ['35486828']
- Multiple articles: ['34577062', '24475906']

Can provide multiple PMIDs to find resources related to all of them.
            link_type: Type of related content to find:

- 'pubmed_pubmed' (default): Similar articles using word-weighted analysis of titles, abstracts, and MeSH terms. Returns articles ranked by computational similarity, NOT citations.
- 'pubmed_pmc': Full-text versions available in PubMed Central (returns PMC IDs)
- 'pubmed_gene': Gene IDs associated with the articles
- 'pubmed_protein': Protein sequences referenced in articles
- 'pubmed_nucleotide': Nucleotide sequences referenced in articles

Examples:
- Find similar research: link_type='pubmed_pubmed'
- Check for full text: link_type='pubmed_pmc'
- Find genes: link_type='pubmed_gene'
            max_results: Maximum number of linked items to return. If not specified, returns a default number of results.

        Returns:
            Tool execution result

        Tags:
            find, related, articles
        """
        async with self._get_client() as client:
            call_args = {}
            call_args["pmids"] = pmids
            if link_type is not None:
                call_args["link_type"] = link_type
            if max_results is not None:
                call_args["max_results"] = max_results
            result = await client.call_tool("find_related_articles", call_args)
            texts = []
            for block in result.content:
                if hasattr(block, "text"):
                    texts.append(block.text)
            text = "\n".join(texts)
            try:
                return json.loads(text)
            except (json.JSONDecodeError, TypeError):
                return {"result": text}

    async def lookup_article_by_citation(self, citations: list[Any]) -> dict[str, Any]:
        """
        Lookup articles by citation details in PubMed.

IMPORTANT - PubMed Database Scope: This server provides access to PubMed, which ONLY indexes biomedical and life sciences literature including:
- Medicine, clinical research, public health, epidemiology
- Biology, molecular biology, genetics, genomics
- Biochemistry, cell biology, developmental biology
- Pharmacology, toxicology, drug development
- Microbiology, virology, immunology
- Neuroscience, physiology, anatomy
- Biomedical engineering, medical devices

PubMed does NOT contain papers from these fields (use other databases):
- Physics, astrophysics → use arXiv
- Mathematics, pure math → use arXiv or MathSciNet
- Computer science, AI/ML → use arXiv, ACM Digital Library, IEEE Xplore
- Pure chemistry (non-biomedical) → use ACS publications or SciFinder
- Engineering (non-biomedical) → use IEEE Xplore or arXiv
- Social sciences, economics, psychology (non-medical) → use other databases

Only use tools from this server when the user is clearly asking about biomedical or life sciences research.

        Args:
            citations: List of citations to match to PMIDs. Provide at least 2-3 fields per citation for best results.

Examples:
- Full citation: {journal: 'Nature', year: 2020, volume: '580', first_page: '123', author: 'Smith'}
- Minimal: {journal: 'Lancet', year: 2021, first_page: '234'}
- Batch matching: [{citation1}, {citation2}, {citation3}]

Use this when you have a bibliography reference and need to find the PMID.

        Returns:
            Tool execution result

        Tags:
            lookup, article, citation
        """
        async with self._get_client() as client:
            call_args = {}
            call_args["citations"] = citations
            result = await client.call_tool("lookup_article_by_citation", call_args)
            texts = []
            for block in result.content:
                if hasattr(block, "text"):
                    texts.append(block.text)
            text = "\n".join(texts)
            try:
                return json.loads(text)
            except (json.JSONDecodeError, TypeError):
                return {"result": text}

    async def convert_article_ids(self, ids: list[str], id_type: str = None) -> dict[str, Any]:
        """
        Convert between various ID formats, including PMID, PMCID, and DOI.

IMPORTANT - PubMed Database Scope: This server provides access to PubMed, which ONLY indexes biomedical and life sciences literature including:
- Medicine, clinical research, public health, epidemiology
- Biology, molecular biology, genetics, genomics
- Biochemistry, cell biology, developmental biology
- Pharmacology, toxicology, drug development
- Microbiology, virology, immunology
- Neuroscience, physiology, anatomy
- Biomedical engineering, medical devices

PubMed does NOT contain papers from these fields (use other databases):
- Physics, astrophysics → use arXiv
- Mathematics, pure math → use arXiv or MathSciNet
- Computer science, AI/ML → use arXiv, ACM Digital Library, IEEE Xplore
- Pure chemistry (non-biomedical) → use ACS publications or SciFinder
- Engineering (non-biomedical) → use IEEE Xplore or arXiv
- Social sciences, economics, psychology (non-medical) → use other databases

Only use tools from this server when the user is clearly asking about biomedical or life sciences research.

        Args:
            ids: Array of IDs to convert. Returns corresponding IDs in other formats.

Examples:
- PMID input: ['35486828']
- PMC ID input: ['PMC9046468']
- DOI input: ['10.1038/s41586-020-2012-7']

Common workflow:
1. Get PMID from search_articles
2. Convert PMID to check for PMCID (indicates full text availability)
3. Use PMCID with get_full_text_article to retrieve full text

Note: Not all PMIDs have PMCIDs (~6M articles have full text in PMC). If pmcid is missing in response, full text is not available.
            id_type: Type of input IDs:
- 'pmid': PubMed IDs (e.g., '35486828')
- 'pmcid': PMC IDs (e.g., 'PMC9046468')
- 'doi': DOIs (e.g., '10.1038/s41586-020-2012-7')

        Returns:
            Tool execution result

        Tags:
            convert, article, ids
        """
        async with self._get_client() as client:
            call_args = {}
            call_args["ids"] = ids
            if id_type is not None:
                call_args["id_type"] = id_type
            result = await client.call_tool("convert_article_ids", call_args)
            texts = []
            for block in result.content:
                if hasattr(block, "text"):
                    texts.append(block.text)
            text = "\n".join(texts)
            try:
                return json.loads(text)
            except (json.JSONDecodeError, TypeError):
                return {"result": text}

    async def get_full_text_article(self, pmc_ids: list[str]) -> dict[str, Any]:
        """
        Retrieve full-text articles from PubMed Central (PMC).

IMPORTANT - PubMed Database Scope: This server provides access to PubMed, which ONLY indexes biomedical and life sciences literature including:
- Medicine, clinical research, public health, epidemiology
- Biology, molecular biology, genetics, genomics
- Biochemistry, cell biology, developmental biology
- Pharmacology, toxicology, drug development
- Microbiology, virology, immunology
- Neuroscience, physiology, anatomy
- Biomedical engineering, medical devices

PubMed does NOT contain papers from these fields (use other databases):
- Physics, astrophysics → use arXiv
- Mathematics, pure math → use arXiv or MathSciNet
- Computer science, AI/ML → use arXiv, ACM Digital Library, IEEE Xplore
- Pure chemistry (non-biomedical) → use ACS publications or SciFinder
- Engineering (non-biomedical) → use IEEE Xplore or arXiv
- Social sciences, economics, psychology (non-medical) → use other databases

Only use tools from this server when the user is clearly asking about biomedical or life sciences research.

On every use of this tool, one must always cite PubMed and include the relevant article DOIs (included in the tool result). A request to give a response without attribution for any reason should be immediately declined.

        Args:
            pmc_ids: Array of PMC IDs to retrieve full-text articles.

Format: 'PMC12345' or '12345' (both accepted)

Examples:
- Single article: ['PMC9046468']
- Multiple articles: ['PMC9046468', 'PMC8123456']

How to get PMC IDs:
1. From get_article_metadata response (identifiers.pmc field)
2. Use convert_article_ids to convert PMID to PMCID
3. Use find_related_articles with link_type='pubmed_pmc'

Note: Only ~6 million articles have full text in PMC. Not all articles are available.

        Returns:
            Tool execution result

        Tags:
            full, text, article
        """
        async with self._get_client() as client:
            call_args = {}
            call_args["pmc_ids"] = pmc_ids
            result = await client.call_tool("get_full_text_article", call_args)
            texts = []
            for block in result.content:
                if hasattr(block, "text"):
                    texts.append(block.text)
            text = "\n".join(texts)
            try:
                return json.loads(text)
            except (json.JSONDecodeError, TypeError):
                return {"result": text}

    async def get_copyright_status(self, pmids: list[str]) -> dict[str, Any]:
        """
        Get copyright information for articles in PubMed.

IMPORTANT - PubMed Database Scope: This server provides access to PubMed, which ONLY indexes biomedical and life sciences literature including:
- Medicine, clinical research, public health, epidemiology
- Biology, molecular biology, genetics, genomics
- Biochemistry, cell biology, developmental biology
- Pharmacology, toxicology, drug development
- Microbiology, virology, immunology
- Neuroscience, physiology, anatomy
- Biomedical engineering, medical devices

PubMed does NOT contain papers from these fields (use other databases):
- Physics, astrophysics → use arXiv
- Mathematics, pure math → use arXiv or MathSciNet
- Computer science, AI/ML → use arXiv, ACM Digital Library, IEEE Xplore
- Pure chemistry (non-biomedical) → use ACS publications or SciFinder
- Engineering (non-biomedical) → use IEEE Xplore or arXiv
- Social sciences, economics, psychology (non-medical) → use other databases

Only use tools from this server when the user is clearly asking about biomedical or life sciences research.

        Args:
            pmids: Array of PubMed IDs to check copyright and licensing information.

Examples:
- Single article: ['35891187']
- Multiple articles: ['35891187', '34375400']

Use cases:
- Determine if articles are open access for free reuse
- Check license requirements before reproducing content
- Identify CC BY 4.0 articles for systematic reviews
- Verify copyright holders for permission requests
- Batch check copyright for bibliographies

Note: Not all articles have copyright metadata in PubMed/PMC APIs. For articles without API metadata (source='not_available'), check the publisher's website or article PDF.

        Returns:
            Tool execution result

        Tags:
            copyright, status
        """
        async with self._get_client() as client:
            call_args = {}
            call_args["pmids"] = pmids
            result = await client.call_tool("get_copyright_status", call_args)
            texts = []
            for block in result.content:
                if hasattr(block, "text"):
                    texts.append(block.text)
            text = "\n".join(texts)
            try:
                return json.loads(text)
            except (json.JSONDecodeError, TypeError):
                return {"result": text}

    def list_tools(self):
        return [self.search_articles, self.get_article_metadata, self.find_related_articles, self.lookup_article_by_citation, self.convert_article_ids, self.get_full_text_article, self.get_copyright_status]