academic-search-mcp 0.1.3__py3-none-any.whl

academic_search_mcp-0.1.3.dist-info/METADATA

@@ -0,0 +1,243 @@
+Metadata-Version: 2.4
+Name: academic-search-mcp
+Version: 0.1.3
+Summary: A MCP server for searching and downloading academic papers from multiple sources.
+Author-email: "P.S Zhang" <pengsongzhang96@gmail.com>
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: curl-cffi>=0.5.0
+Requires-Dist: fastmcp
+Requires-Dist: feedparser
+Requires-Dist: httpx[socks]>=0.28.1
+Requires-Dist: lxml>=4.9.0
+Requires-Dist: mcp[cli]>=1.6.0
+Requires-Dist: pypdf2>=3.0.0
+Requires-Dist: requests
+Description-Content-Type: text/markdown
+
+# Academic Search MCP
+
+A Model Context Protocol (MCP) server for searching and downloading academic papers from multiple sources. Designed for seamless integration with large language models like Claude Desktop.
+
+> **Fork Notice**: This is an extended fork of [openags/academic-search-mcp](https://github.com/openags/academic-search-mcp) with additional platforms (CORE, SSRN, CyberLeninka) and improvements.
+
+![License](https://img.shields.io/badge/license-MIT-blue.svg) ![Python](https://img.shields.io/badge/python-3.10+-blue.svg)
+
+---
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Features](#features)
+- [Installation](#installation)
+  - [Quick Start](#quick-start)
+    - [Install Package](#install-package)
+    - [Configure Claude Desktop](#configure-claude-desktop)
+  - [For Development](#for-development)
+    - [Setup Environment](#setup-environment)
+    - [Install Dependencies](#install-dependencies)
+- [Contributing](#contributing)
+- [Demo](#demo)
+- [License](#license)
+- [TODO](#todo)
+
+---
+
+## Overview
+
+`academic-search-mcp` is a Python-based MCP server that enables users to search and download academic papers from various platforms. It provides tools for searching papers (e.g., `search_arxiv`) and downloading PDFs (e.g., `download_arxiv`), making it ideal for researchers and AI-driven workflows. Built with the MCP Python SDK, it integrates seamlessly with LLM clients like Claude Desktop.
+
+---
+
+## Features
+
+- **Multi-Source Support**: Search and download papers from arXiv, PubMed, bioRxiv, medRxiv, Google Scholar, IACR ePrint Archive, Semantic Scholar, CrossRef, OpenAlex, CORE, SSRN, and CyberLeninka.
+- **Date Filtering**: All sources support `date_from` and `date_to` parameters (YYYY-MM-DD format) to filter papers by publication date.
+- **Citation Counts**: OpenAlex, Semantic Scholar, CrossRef, and Google Scholar include citation counts in search results.
+- **Citation Graph**: OpenAlex tools to explore references (papers a work cites) and citations (papers citing a work), sorted by impact.
+- **Open Access PDFs**: OpenAlex includes PDF URLs for open access papers.
+- **Token-Optimized Output**: Configurable `abstract_limit` parameter to control abstract length (default: 200 chars, use -1 for full, 0 to omit).
+- **Standardized Output**: Papers are returned in a consistent, compact dictionary format via the `Paper` class.
+- **Asynchronous Tools**: Efficiently handles network requests using `httpx`.
+- **MCP Integration**: Compatible with MCP clients for LLM context enhancement.
+- **Extensible Design**: Easily add new academic platforms by extending the `academic_platforms` module.
+
+### Search Parameters
+
+All search tools support these common parameters:
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `query` | str | required | Search query string |
+| `max_results` | int | 10 | Maximum number of papers to return |
+| `abstract_limit` | int | 200 | Max chars for abstract (0=omit, -1=full) |
+| `date_from` | str | None | Start date in YYYY-MM-DD format |
+| `date_to` | str | None | End date in YYYY-MM-DD format |
+
+> **Note**: Google Scholar only supports year-level filtering (month/day are ignored).
+
+---
+
+## Installation
+
+### Quick Start with uvx
+
+The easiest way to use `academic-search-mcp`:
+
+```bash
+uvx academic-search-mcp
+```
+
+Or install globally:
+
+```bash
+uv tool install academic-search-mcp
+```
+
+### Configure Claude Desktop
+
+Add this configuration to `~/Library/Application Support/Claude/claude_desktop_config.json` (Mac) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "academic_search": {
+      "command": "uvx",
+      "args": ["academic-search-mcp"]
+    }
+  }
+}
+```
+
+### Alternative: Install with pip/uv
+
+```bash
+pip install academic-search-mcp
+# or
+uv add academic-search-mcp
+```
+
+2. **Configure Claude Desktop (alternative)**:
+   Add this configuration to `~/Library/Application Support/Claude/claude_desktop_config.json` (Mac) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+   ```json
+   {
+     "mcpServers": {
+       "paper_search_server": {
+         "command": "uv",
+         "args": [
+           "run",
+           "--directory",
+           "/path/to/your/academic-search-mcp",
+           "-m",
+           "paper_search_mcp.server"
+         ],
+         "env": {
+           "SEMANTIC_SCHOLAR_API_KEY": "", // Optional: For enhanced Semantic Scholar features
+           "CORE_API_KEY": "" // Optional: for CORE repository access
+         }
+       }
+     }
+   }
+   ```
+   > Note: Replace `/path/to/your/academic-search-mcp` with your actual installation path.
+
+### For Development
+
+For developers who want to modify the code or contribute:
+
+1. **Setup Environment**:
+
+   ```bash
+   # Install uv if not installed
+   curl -LsSf https://astral.sh/uv/install.sh | sh
+
+   # Clone repository
+   git clone https://github.com/openags/academic-search-mcp.git
+   cd academic-search-mcp
+
+   # Create and activate virtual environment
+   uv venv
+   source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+   ```
+
+2. **Install Dependencies**:
+
+   ```bash
+   # Install project in editable mode
+   uv add -e .
+
+   # Add development dependencies (optional)
+   uv add pytest flake8
+   ```
+
+---
+
+## Contributing
+
+We welcome contributions! Here's how to get started:
+
+1. **Fork the Repository**:
+   Click "Fork" on GitHub.
+
+2. **Clone and Set Up**:
+
+   ```bash
+   git clone https://github.com/yourusername/academic-search-mcp.git
+   cd academic-search-mcp
+   pip install -e ".[dev]"  # Install dev dependencies (if added to pyproject.toml)
+   ```
+
+3. **Make Changes**:
+
+   - Add new platforms in `academic_platforms/`.
+   - Update tests in `tests/`.
+
+4. **Submit a Pull Request**:
+   Push changes and create a PR on GitHub.
+
+---
+
+## Demo
+
+<img src="docs\images\demo.png" alt="Demo" width="800">
+
+## TODO
+
+### Planned Academic Platforms
+
+- [x] arXiv
+- [x] PubMed
+- [x] bioRxiv
+- [x] medRxiv
+- [x] Google Scholar
+- [x] IACR ePrint Archive
+- [x] Semantic Scholar
+- [x] CrossRef
+- [x] OpenAlex
+- [x] CORE (200M+ open access papers)
+- [x] SSRN (social sciences, law, business preprints)
+- [x] CyberLeninka (Russian academic papers, VAK/RSCI/SCOPUS filters)
+- [ ] PubMed Central (PMC)
+- [ ] Science Direct
+- [ ] Springer Link
+- [ ] IEEE Xplore
+- [ ] ACM Digital Library
+- [ ] Web of Science
+- [ ] Scopus
+- [ ] JSTOR
+- [ ] ResearchGate
+
+---
+
+## License
+
+This project is licensed under the MIT License. See the LICENSE file for details.
+
+---
+
+Happy researching with `academic-search-mcp`!
+
+## Credits
+
+Based on [openags/paper-search-mcp](https://github.com/openags/paper-search-mcp) by P.S Zhang.

academic_search_mcp-0.1.3.dist-info/RECORD

@@ -0,0 +1,24 @@
+paper_search_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+paper_search_mcp/paper.py,sha256=Flrn3ORhsojiEdEldUtKPvGF1RivXhl84zzq8mqAeFI,2969
+paper_search_mcp/pdf_utils.py,sha256=sylqOQTFyOSlYnEzUMpSIe4VkY2kfgaQw_xd_EBYw2g,1909
+paper_search_mcp/server.py,sha256=C542TF00oOUHF38F_5OU43D9RmIWQZSk7UiFHcXukWA,21663
+paper_search_mcp/academic_platforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+paper_search_mcp/academic_platforms/arxiv.py,sha256=5SsFudqH1PIXIEE_8saCQHcf75bqCL6ApRUltLpp9Ow,5911
+paper_search_mcp/academic_platforms/biorxiv.py,sha256=4k1Bg2BW-RBJiZ9jRVVmCEOge_4MtEDtXq2tMaPV0cg,6799
+paper_search_mcp/academic_platforms/core.py,sha256=6xDq3NmlVh1NIEFnTRLPNayodkztrS7CPUC-jupd-Lw,9632
+paper_search_mcp/academic_platforms/crossref.py,sha256=Zxj4U6SejaCa5o7whRmjjHVdd1U1H-DVtRP6DWzPwjk,14773
+paper_search_mcp/academic_platforms/cyberleninka.py,sha256=88p9RZxjBRn5jAaOhZLr3EpP5ibMzmd0vCh1jD6PPEs,13421
+paper_search_mcp/academic_platforms/google_scholar.py,sha256=B8VqgauJy3RJ8nR9woe107CXM-DrHQPapQAg_f948yg,9269
+paper_search_mcp/academic_platforms/hub.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+paper_search_mcp/academic_platforms/iacr.py,sha256=Vem7q18NZRm5WXsDHsqRefyRIpl4PCceGGWYXhbXB2s,21135
+paper_search_mcp/academic_platforms/medrxiv.py,sha256=tsbeO5RK-apz2mKKJruFCS19-BRG4jikwO4XXwqiktM,6772
+paper_search_mcp/academic_platforms/openalex.py,sha256=lsWB_XlYufbQTNbR2ZT7tg7b74_FwYvxBcDt-YYBuYE,17792
+paper_search_mcp/academic_platforms/pubmed.py,sha256=oS-JRHNI7lcCqxUGTlSVKp2i_QKuClwVUc6cA33URhE,6480
+paper_search_mcp/academic_platforms/sci_hub.py,sha256=oma3M_gUseDByh-0Awi8Sxr0g3yojrb8XoD9iV0Exo8,7334
+paper_search_mcp/academic_platforms/semantic.py,sha256=nk7nzrlsnrDNrHNUuRIfIBQfagfAT750J5HtdLputHQ,20594
+paper_search_mcp/academic_platforms/ssrn.py,sha256=ntf22HRBZwNY6ctG5rdXjD5iT7CaML8k_xBbCn_qjbg,13694
+academic_search_mcp-0.1.3.dist-info/METADATA,sha256=uZcbHayXO9tURHo3Yl7P50e4j3v4p20a7GoPbtlLTe4,7203
+academic_search_mcp-0.1.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+academic_search_mcp-0.1.3.dist-info/entry_points.txt,sha256=RO1wFwD6a0WO_mZY8HZBYDtITfQ1dhnTR1BZlCrkRLc,69
+academic_search_mcp-0.1.3.dist-info/licenses/LICENSE,sha256=TwRnWq1drFhdcy43SdxndU0mcfBUYBnhSJTJ4hhjfwQ,1085
+academic_search_mcp-0.1.3.dist-info/RECORD,,

academic_search_mcp-0.1.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

academic_search_mcp-0.1.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+academic-search-mcp = paper_search_mcp.server:main

academic_search_mcp-0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OPENAGS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

paper_search_mcp/academic_platforms/arxiv.py

@@ -0,0 +1,147 @@
+# paper_search_mcp/sources/arxiv.py
+from typing import List
+from datetime import datetime
+import requests
+import feedparser
+from ..paper import Paper
+from PyPDF2 import PdfReader
+import os
+
+class PaperSource:
+    """Abstract base class for paper sources"""
+    def search(self, query: str, **kwargs) -> List[Paper]:
+        raise NotImplementedError
+
+    def download_pdf(self, paper_id: str, save_path: str) -> str:
+        raise NotImplementedError
+
+    def read_paper(self, paper_id: str, save_path: str) -> str:
+        raise NotImplementedError
+
+class ArxivSearcher(PaperSource):
+    """Searcher for arXiv papers"""
+    BASE_URL = "http://export.arxiv.org/api/query"
+
+    def search(self, query: str, max_results: int = 10,
+               date_from: str = None, date_to: str = None) -> List[Paper]:
+        """Search arXiv papers.
+
+        Args:
+            query: Search query string
+            max_results: Maximum number of results
+            date_from: Start date in YYYY-MM-DD format (optional)
+            date_to: End date in YYYY-MM-DD format (optional)
+        """
+        # Build query with date filter if specified
+        # Format: submittedDate:[YYYYMMDDHHMM TO YYYYMMDDHHMM]
+        # Note: Must use field prefix (all:, ti:, abs:) with date filter
+        search_query = query
+        if date_from or date_to:
+            start = date_from.replace('-', '') + '0000' if date_from else '190001010000'
+            end = date_to.replace('-', '') + '2359' if date_to else '209912312359'
+            # Wrap query in all: if not already using a field prefix
+            if not any(query.startswith(p) for p in ['ti:', 'abs:', 'au:', 'cat:', 'all:']):
+                search_query = f'all:"{query}" AND submittedDate:[{start} TO {end}]'
+            else:
+                search_query = f'{query} AND submittedDate:[{start} TO {end}]'
+
+        params = {
+            'search_query': search_query,
+            'max_results': max_results,
+            'sortBy': 'submittedDate',
+            'sortOrder': 'descending'
+        }
+        response = requests.get(self.BASE_URL, params=params)
+        feed = feedparser.parse(response.content)
+        papers = []
+        for entry in feed.entries:
+            try:
+                authors = [author.name for author in entry.authors]
+                published = datetime.strptime(entry.published, '%Y-%m-%dT%H:%M:%SZ')
+                updated = datetime.strptime(entry.updated, '%Y-%m-%dT%H:%M:%SZ')
+                pdf_url = next((link.href for link in entry.links if link.type == 'application/pdf'), '')
+                papers.append(Paper(
+                    paper_id=entry.id.split('/')[-1],
+                    title=entry.title,
+                    authors=authors,
+                    abstract=entry.summary,
+                    url=entry.id,
+                    pdf_url=pdf_url,
+                    published_date=published,
+                    updated_date=updated,
+                    source='arxiv',
+                    categories=[tag.term for tag in entry.tags],
+                    keywords=[],
+                    doi=entry.get('doi', '')
+                ))
+            except Exception as e:
+                print(f"Error parsing arXiv entry: {e}")
+        return papers
+
+    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:
+            f.write(response.content)
+        return output_file
+
+    def read_paper(self, paper_id: str, save_path: str = "./downloads") -> str:
+        """Read a paper and convert it to text format.
+
+        Args:
+            paper_id: arXiv paper ID
+            save_path: Directory where the PDF is/will be saved
+
+        Returns:
+            str: The extracted text content of the paper
+        """
+        from ..pdf_utils import extract_text_from_pdf
+
+        # First ensure we have the PDF
+        pdf_path = f"{save_path}/{paper_id}.pdf"
+        if not os.path.exists(pdf_path):
+            pdf_path = self.download_pdf(paper_id, save_path)
+
+        return extract_text_from_pdf(pdf_path)
+
+if __name__ == "__main__":
+    # 测试 ArxivSearcher 的功能
+    searcher = ArxivSearcher()
+    
+    # 测试搜索功能
+    print("Testing search functionality...")
+    query = "machine learning"
+    max_results = 5
+    try:
+        papers = searcher.search(query, max_results=max_results)
+        print(f"Found {len(papers)} papers for query '{query}':")
+        for i, paper in enumerate(papers, 1):
+            print(f"{i}. {paper.title} (ID: {paper.paper_id})")
+    except Exception as e:
+        print(f"Error during search: {e}")
+    
+    # 测试 PDF 下载功能
+    if papers:
+        print("\nTesting PDF download functionality...")
+        paper_id = papers[0].paper_id
+        save_path = "./downloads"  # 确保此目录存在
+        try:
+            os.makedirs(save_path, exist_ok=True)
+            pdf_path = searcher.download_pdf(paper_id, save_path)
+            print(f"PDF downloaded successfully: {pdf_path}")
+        except Exception as e:
+            print(f"Error during PDF download: {e}")
+
+    # 测试论文阅读功能
+    if papers:
+        print("\nTesting paper reading functionality...")
+        paper_id = papers[0].paper_id
+        try:
+            text_content = searcher.read_paper(paper_id)
+            print(f"\nFirst 500 characters of the paper content:")
+            print(text_content[:500] + "...")
+            print(f"\nTotal length of extracted text: {len(text_content)} characters")
+        except Exception as e:
+            print(f"Error during paper reading: {e}")

paper_search_mcp/academic_platforms/biorxiv.py

@@ -0,0 +1,156 @@
+from typing import List
+import requests
+import os
+from datetime import datetime, timedelta
+from ..paper import Paper
+from PyPDF2 import PdfReader
+
+class PaperSource:
+    """Abstract base class for paper sources"""
+    def search(self, query: str, **kwargs) -> List[Paper]:
+        raise NotImplementedError
+
+    def download_pdf(self, paper_id: str, save_path: str) -> str:
+        raise NotImplementedError
+
+    def read_paper(self, paper_id: str, save_path: str) -> str:
+        raise NotImplementedError
+
+class BioRxivSearcher(PaperSource):
+    """Searcher for bioRxiv papers"""
+    BASE_URL = "https://api.biorxiv.org/details/biorxiv"
+
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.proxies = {'http': None, 'https': None}
+        self.timeout = 30
+        self.max_retries = 3
+
+    def search(self, query: str, max_results: int = 10, days: int = 30,
+               date_from: str = None, date_to: str = None) -> List[Paper]:
+        """
+        Search for papers on bioRxiv by category within a date range.
+
+        Args:
+            query: Category name to search for (e.g., "cell biology").
+            max_results: Maximum number of papers to return.
+            days: Number of days to look back for papers (used if date_from/date_to not specified).
+            date_from: Start date in YYYY-MM-DD format (optional, overrides days).
+            date_to: End date in YYYY-MM-DD format (optional, defaults to today).
+
+        Returns:
+            List of Paper objects matching the category within the specified date range.
+        """
+        # Use date_from/date_to if provided, otherwise fall back to days parameter
+        if date_from or date_to:
+            end_date = date_to if date_to else datetime.now().strftime('%Y-%m-%d')
+            start_date = date_from if date_from else '1900-01-01'
+        else:
+            # Calculate date range: last N days
+            end_date = datetime.now().strftime('%Y-%m-%d')
+            start_date = (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d')
+        
+        # Format category: lowercase and replace spaces with underscores
+        category = query.lower().replace(' ', '_')
+        
+        papers = []
+        cursor = 0
+        while len(papers) < max_results:
+            url = f"{self.BASE_URL}/{start_date}/{end_date}/{cursor}"
+            if category:
+                url += f"?category={category}"
+            tries = 0
+            while tries < self.max_retries:
+                try:
+                    response = self.session.get(url, timeout=self.timeout)
+                    response.raise_for_status()
+                    data = response.json()
+                    collection = data.get('collection', [])
+                    for item in collection:
+                        try:
+                            date = datetime.strptime(item['date'], '%Y-%m-%d')
+                            papers.append(Paper(
+                                paper_id=item['doi'],
+                                title=item['title'],
+                                authors=item['authors'].split('; '),
+                                abstract=item['abstract'],
+                                url=f"https://www.biorxiv.org/content/{item['doi']}v{item.get('version', '1')}",
+                                pdf_url=f"https://www.biorxiv.org/content/{item['doi']}v{item.get('version', '1')}.full.pdf",
+                                published_date=date,
+                                updated_date=date,
+                                source="biorxiv",
+                                categories=[item['category']],
+                                keywords=[],
+                                doi=item['doi']
+                            ))
+                        except Exception as e:
+                            print(f"Error parsing bioRxiv entry: {e}")
+                    if len(collection) < 100:
+                        break  # No more results
+                    cursor += 100
+                    break  # Exit retry loop on success
+                except requests.exceptions.RequestException as e:
+                    tries += 1
+                    if tries == self.max_retries:
+                        print(f"Failed to connect to bioRxiv API after {self.max_retries} attempts: {e}")
+                        break
+                    print(f"Attempt {tries} failed, retrying...")
+            else:
+                continue
+            break
+
+        return papers[:max_results]
+
+    def download_pdf(self, paper_id: str, save_path: str) -> str:
+        """
+        Download a PDF for a given paper ID from bioRxiv.
+
+        Args:
+            paper_id: The DOI of the paper.
+            save_path: Directory to save the PDF.
+
+        Returns:
+            Path to the downloaded PDF file.
+        """
+        if not paper_id:
+            raise ValueError("Invalid paper_id: paper_id is empty")
+
+        pdf_url = f"https://www.biorxiv.org/content/{paper_id}v1.full.pdf"
+        tries = 0
+        while tries < self.max_retries:
+            try:
+                # Add User-Agent to avoid potential 403 errors
+                headers = {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+                }
+                response = self.session.get(pdf_url, timeout=self.timeout, headers=headers)
+                response.raise_for_status()
+                os.makedirs(save_path, exist_ok=True)
+                output_file = f"{save_path}/{paper_id.replace('/', '_')}.pdf"
+                with open(output_file, 'wb') as f:
+                    f.write(response.content)
+                return output_file
+            except requests.exceptions.RequestException as e:
+                tries += 1
+                if tries == self.max_retries:
+                    raise Exception(f"Failed to download PDF after {self.max_retries} attempts: {e}")
+                print(f"Attempt {tries} failed, retrying...")
+    
+    def read_paper(self, paper_id: str, save_path: str = "./downloads") -> str:
+        """
+        Read a paper and convert it to text format.
+
+        Args:
+            paper_id: bioRxiv DOI
+            save_path: Directory where the PDF is/will be saved
+
+        Returns:
+            str: The extracted text content of the paper
+        """
+        from ..pdf_utils import extract_text_from_pdf
+
+        pdf_path = f"{save_path}/{paper_id.replace('/', '_')}.pdf"
+        if not os.path.exists(pdf_path):
+            pdf_path = self.download_pdf(paper_id, save_path)
+
+        return extract_text_from_pdf(pdf_path)