github · paper-search-mcpHEAD

Evidence

response.raise_for_status()

                # Parse XML response

                root = ET.fromstring(response.content)

                # Check for OAI-PMH errors

                error_elem = root.find(f'.//{{{OAI_NS}}}error')

Remediation

Use defusedxml in Python (drop-in replacement for stdlib XML modules). In Java, set XMLConstants.FEATURE_SECURE_PROCESSING=true and disable external-DTD features on the factory before parsing.

Evidence

continue

                    response.raise_for_status()

                    root = ET.fromstring(response.content)

                    papers: List[Paper] = []

                    result_nodes = self._find_top_level_results(root)

Remediation

Use defusedxml in Python (drop-in replacement for stdlib XML modules). In Java, set XMLConstants.FEATURE_SECURE_PROCESSING=true and disable external-DTD features on the factory before parsing.

Evidence

summary_response = self.session.get(self.EUTILS_SUMMARY_URL, params=summary_params, timeout=30)

            summary_response.raise_for_status()

            summary_root = ET.fromstring(summary_response.content)

            # Step 3: Parse each summary record

            for docsum in summary_root.findall('.//DocSum'):

Remediation

Use defusedxml in Python (drop-in replacement for stdlib XML modules). In Java, set XMLConstants.FEATURE_SECURE_PROCESSING=true and disable external-DTD features on the factory before parsing.

Evidence

'retmode': 'xml'

        }

        fetch_response = requests.get(self.FETCH_URL, params=fetch_params)

        fetch_root = ET.fromstring(fetch_response.content)

        papers = []

        for article in fetch_root.findall('.//PubmedArticle'):

Remediation

Use defusedxml in Python (drop-in replacement for stdlib XML modules). In Java, set XMLConstants.FEATURE_SECURE_PROCESSING=true and disable external-DTD features on the factory before parsing.

Evidence

search_response = self.session.get(self.EUTILS_SEARCH_URL, params=search_params, timeout=30)

            search_response.raise_for_status()

            search_root = ET.fromstring(search_response.content)

            # Get PMC IDs

            pmcids = [id_elem.text for id_elem in search_root.findall('.//Id') if id_elem.text]

Remediation

Use defusedxml in Python (drop-in replacement for stdlib XML modules). In Java, set XMLConstants.FEATURE_SECURE_PROCESSING=true and disable external-DTD features on the factory before parsing.

Evidence

raise requests.RequestException("dblp API unavailable")

            # Parse XML response

            root = ET.fromstring(response.content)

            # dblp XML structure: result > hits > hit > info

            hits = root.findall('.//hit')

Remediation

Use defusedxml in Python (drop-in replacement for stdlib XML modules). In Java, set XMLConstants.FEATURE_SECURE_PROCESSING=true and disable external-DTD features on the factory before parsing.

Evidence

'sort': sort,

        }

        search_response = requests.get(self.SEARCH_URL, params=search_params)

        search_root = ET.fromstring(search_response.content)

        ids = [id.text for id in search_root.findall('.//Id') if id.text]

        if not ids:

            return []

Remediation

Use defusedxml in Python (drop-in replacement for stdlib XML modules). In Java, set XMLConstants.FEATURE_SECURE_PROCESSING=true and disable external-DTD features on the factory before parsing.

Evidence

# Search on Sci-Hub

            search_url = f"{self.base_url}/{identifier}"

            response = self.session.get(search_url, verify=False, timeout=20)

            if response.status_code != 200:

                return None

            soup = BeautifulSoup(response.content, 'html.parser')

            # Check for article not found

            if "article not found" in response.text.lower():

Remediation

Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.

Evidence

return None

            # Download the PDF

            response = self.session.get(pdf_url, verify=False, timeout=30)

            if response.status_code != 200:

                logging.error(f"Failed to download PDF, status {response.status_code}")

                return None

            if response.headers.get('Content-Type') != 'application/pdf':

Remediation

Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.

Evidence

else:

        query = "climate change"

    print(f"Searching OpenAIRE for: {query}")

    papers = searcher.search(query, max_results=5)

    print(f"Found {len(papers)} papers:")

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

]

    for query in test_queries[:1]:  # Test first query only

        print(f"\nSearching BASE for: '{query}'")

        papers = searcher.search(query, max_results=3)

        print(f"Found {len(papers)} papers")

        for i, paper in enumerate(papers):

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

]

    for query in test_queries[:1]:  # Test first query only

        print(f"\nSearching DOAJ for: '{query}'")

        papers = searcher.search(query, max_results=3)

        print(f"Found {len(papers)} papers")

        for i, paper in enumerate(papers):

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

else:

        query = "machine learning"

    print(f"Searching CiteSeerX for: {query}")

    papers = searcher.search(query, max_results=5)

    print(f"Found {len(papers)} papers:")

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

]

    for query in test_queries[:1]:  # Test first query only

        print(f"\nSearching ChemRxiv for: '{query}'")

        papers = searcher.search(query, max_results=3)

        print(f"Found {len(papers)} preprints")

        for i, paper in enumerate(papers):

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

else:

        query = "machine learning"

    print(f"Searching dblp for: {query}")

    papers = searcher.search(query, max_results=5)

    print(f"Found {len(papers)} papers:")

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

try:

        return pubmed_searcher.download_pdf(paper_id, save_path)

    except NotImplementedError as e:

        return str(e)

@mcp.tool()

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

try:

        return crossref_searcher.download_pdf(paper_id, save_path)

    except NotImplementedError as e:

        return str(e)

@mcp.tool()

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

}

            except Exception as e:

                logger.error(f"Error requesting API: {e}")

                return {"error": "general_error", "message": str(e)}

        return {

            "error": "max_retries_exceeded",

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

def download_pdf(self, paper_id: str, save_path: str) -> str:

        pdf_url = f"https://arxiv.org/pdf/{paper_id}.pdf"

        response = requests.get(pdf_url)

        os.makedirs(save_path, exist_ok=True)

        output_file = f"{save_path}/{paper_id}.pdf"

        with open(output_file, 'wb') as f:

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

'id': ','.join(ids),

            'retmode': 'xml'

        }

        fetch_response = requests.get(self.FETCH_URL, params=fetch_params)

        fetch_root = ET.fromstring(fetch_response.content)

        papers = []

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

'retmode': 'xml',

            'sort': sort,

        }

        search_response = requests.get(self.SEARCH_URL, params=search_params)

        search_root = ET.fromstring(search_response.content)

        ids = [id.text for id in search_root.findall('.//Id') if id.text]

        if not ids:

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

# Multi-stage build for smaller image

FROM python:3.12-slim AS builder

WORKDIR /app

COPY pyproject.toml README.md LICENSE ./

COPY paper_search_mcp/ paper_search_mcp/

RUN pip install --no-cache-dir build \

    && python -m build --wheel \

    && pip install --no-cache-dir dist/*.whl

FROM python:3.12-slim

WORKDIR /app

COPY --from=builder /usr/local/lib/python3.12/site-packages /usr/local/lib/python3.12/site-packages

COPY --from=builder /usr/local/bin/paper-search-mcp /usr/local/bin/paper-searc

Remediation

Create and switch to a non-root user before the CMD / ENTRYPOINT: RUN adduser --system --uid 1000 app USER 1000 Or reuse the base image's shipped non-root account (e.g. `USER nobody`, `USER nonroot` on distroless). Multi-stage builds only need the USER directive in the final stage.

Evidence

uses: actions/checkout@v4

      - name: Set up Python ${{ matrix.python-version }}

        uses: actions/setup-python@v5

        with:

          python-version: ${{ matrix.python-version }}

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

python-version: ${{ matrix.python-version }}

      - name: Install uv

        uses: astral-sh/setup-uv@v4

      - name: Install dependencies

        run: uv pip install --system -e ".[dev]" 2>/dev/null || uv pip install --system -e .

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

id-token: write

    steps:

      - name: Checkout code

        uses: actions/checkout@v4

      - name: Set up Python

        uses: actions/setup-python@v5

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

python-version: ['3.10', '3.12', '3.13']

    steps:

      - name: Checkout code

        uses: actions/checkout@v4

      - name: Set up Python ${{ matrix.python-version }}

        uses: actions/setup-python@v5

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

uses: actions/checkout@v4

      - name: Set up Python

        uses: actions/setup-python@v5

        with:

          python-version: '3.10'

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

run: uv build

      - name: Publish to PyPI

        uses: pypa/gh-action-pypi-publish@release/v1

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

python-version: '3.10'

      - name: Install uv

        uses: astral-sh/setup-uv@v4

      - name: Build package

        run: uv build

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

pub_date = datetime.strptime(date_str, '%Y-%m-%d')

                except ValueError:

                    try:

                        pub_date = datetime.strptime(pub_year, '%Y')

                    except ValueError:

                        pass

            # Extract URLs

            url = item.get('fullTextUrlList', {}).get('fullTextUrl', [])

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

if year_match:

            try:

                year = int(year_match.group())

                return datetime(year, 1, 1)

            except ValueError:

                pass

        return None

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

published_date = None

            if year and year.isdigit():

                try:

                    published_date = datetime(int(year), 1, 1)

                except ValueError:

                    pass

            # Extract venue

            venue = info.get('venue', '')

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

pub_date = datetime.strptime(date_str, '%Y-%m-%d')

                    except ValueError:

                        try:

                            pub_date = datetime.strptime(year, '%Y')

                        except ValueError:

                            pass

            # Construct URLs

            url = f"https://www.ncbi.nlm.nih.gov/pmc/articles/{pmcid}/"

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

published_date = datetime.fromisoformat(date_str.replace('Z', '+00:00'))

                    except ValueError:

                        try:

                            published_date = datetime.strptime(date_str[:10], '%Y-%m-%d')

                        except ValueError:

                            pass

            # Extract URLs

            url = ''

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

return head.url if head.url else candidate

            # Even if content-type is not pdf, if redirect lands at a PDF URL, use it

            if head.status_code == 200:

                return candidate

        except Exception:

            pass

        return ""

    def _parse_doc(self, doc: Dict[str, Any]) -> Optional[Paper]:

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

published_date = None

            if year_str and year_str.isdigit():

                try:

                    published_date = datetime(int(year_str), 1, 1)

                except ValueError:

                    pass

            # Construct paper ID (use dblp key if available, otherwise generate)

            paper_id = ""

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

if not last_updated:

                        date_str = line.split(":")[0].strip()

                        try:

                            last_updated = datetime.strptime(date_str, "%Y-%m-%d")

                        except ValueError:

                            pass

                elif history_found and (

                    line.strip().startswith("Short URL")

                    or line.strip().startswith("License")

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

except (ValueError, TypeError):

                    # Try just year

                    try:

                        published_date = datetime(int(year), 1, 1)

                    except (ValueError, TypeError):

                        pass

            # Extract journal information

            journal = bibjson.get('journal', {})

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

# Try just year

                        year = published_date[:4]

                        if year.isdigit():

                            pub_date = datetime(int(year), 1, 1)

                    except Exception:

                        pass

            # Extract URLs

            url = item.get('url', '')

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

published_date = None

                if pub_date_str:

                    try:

                        published_date = datetime.strptime(pub_date_str, "%Y-%m-%d")

                    except ValueError:

                        pass

                # Categories / Concepts

                concepts = [

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.