aiagents4pharma 1.38.0__tar.gz → 1.39.0__tar.gz

{aiagents4pharma-1.38.0 → aiagents4pharma-1.39.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiagents4pharma
-Version: 1.38.0
+Version: 1.39.0
 Summary: AI Agents for drug discovery, drug development, and other pharmaceutical R&D.
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License

{aiagents4pharma-1.38.0 → aiagents4pharma-1.39.0}/aiagents4pharma/talk2scholars/agents/paper_download_agent.py

@@ -14,6 +14,8 @@ from langgraph.prebuilt.tool_node import ToolNode
 from langgraph.checkpoint.memory import MemorySaver
 from ..state.state_talk2scholars import Talk2Scholars
 from ..tools.paper_download.download_arxiv_input import download_arxiv_paper
+from ..tools.paper_download.download_medrxiv_input import download_medrxiv_paper
+from ..tools.paper_download.download_biorxiv_input import download_biorxiv_paper
 
 # Initialize logger
 logging.basicConfig(level=logging.INFO)
@@ -24,14 +26,20 @@ def get_app(uniq_id, llm_model: BaseChatModel):
     """
     Initializes and returns the LangGraph application for the Talk2Scholars paper download agent.
 
+    This agent supports downloading scientific papers from multiple preprint servers, including
+    arXiv, BioRxiv, and MedRxiv. It can intelligently handle user queries by extracting or resolving
+    necessary identifiers (e.g., arXiv ID or DOI) from the paper title and routing the request to
+    the appropriate download tool.
+
     Args:
         uniq_id (str): A unique identifier for tracking the current session.
         llm_model (BaseChatModel, optional): The language model to be used by the agent.
-            Defaults to ChatOpenAI(model="gpt-4o-mini", temperature=0.5).
+        Defaults to ChatOpenAI(model="gpt-4o-mini", temperature=0.5).
 
     Returns:
         StateGraph: A compiled LangGraph application that enables the paper download agent to
-            process user queries and retrieve arXiv papers.
+        process user queries and retrieve research papers from arXiv (using arXiv ID),
+        BioRxiv and MedRxiv (using DOI resolved from the paper title or provided directly).
     """
 
     # Load Hydra configuration
@@ -44,7 +52,7 @@ def get_app(uniq_id, llm_model: BaseChatModel):
         cfg = cfg.agents.talk2scholars.paper_download_agent
 
     # Define tools properly
-    tools = ToolNode([download_arxiv_paper])
+    tools = ToolNode([download_arxiv_paper, download_medrxiv_paper, download_biorxiv_paper])
 
     # Define the model
     logger.info("Using OpenAI model %s", llm_model)
@@ -58,7 +66,7 @@ def get_app(uniq_id, llm_model: BaseChatModel):
 
     def paper_download_agent_node(state: Talk2Scholars) -> Dict[str, Any]:
         """
-        Processes the current state to fetch the arXiv paper.
+        Processes the current state to fetch the research paper from arXiv, BioRxiv, or MedRxiv.
         """
         logger.info("Creating paper download agent node with thread_id: %s", uniq_id)
         result = model.invoke(state, {"configurable": {"thread_id": uniq_id}})

{aiagents4pharma-1.38.0 → aiagents4pharma-1.39.0}/aiagents4pharma/talk2scholars/configs/config.yaml

@@ -8,6 +8,8 @@ defaults:
   - agents/talk2scholars/pdf_agent: default
   - tools/search: default
   - tools/download_arxiv_paper: default
+  - tools/download_biorxiv_paper: default
+  - tools/download_medrxiv_paper: default
   - tools/single_paper_recommendation: default
   - tools/multi_paper_recommendation: default
   - tools/retrieve_semantic_scholar_paper_id: default

aiagents4pharma-1.39.0/aiagents4pharma/talk2scholars/configs/tools/zotero_read/__init__.py

@@ -0,0 +1,3 @@
+"""
+Import all the modules in the package
+"""

aiagents4pharma-1.39.0/aiagents4pharma/talk2scholars/configs/tools/zotero_write/__inti__.py

@@ -0,0 +1,3 @@
+"""
+Import all the modules in the package
+"""

aiagents4pharma-1.39.0/aiagents4pharma/talk2scholars/tests/test_paper_download_biorxiv.py

@@ -0,0 +1,151 @@
+"""
+Unit tests for bioRxiv paper downloading functionality, including:
+- download_bioRxiv_paper tool function.
+"""
+
+import unittest
+from unittest.mock import MagicMock, patch
+from langchain_core.messages import ToolMessage
+
+from aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input import (
+    download_biorxiv_paper,
+)
+
+
+class TestDownloadBiorxivPaper(unittest.TestCase):
+    """Tests for the download_bioRxiv_paper tool."""
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.hydra.initialize"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.hydra.compose"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.requests.get"
+    )
+    def test_download_biorxiv_paper_success(self, mock_get, mock_compose, mock_initialize):
+        """Test successful metadata and PDF URL retrieval."""
+        dummy_cfg = MagicMock()
+        dummy_cfg.tools.download_biorxiv_paper.api_url = "http://dummy.biorxiv.org/api"
+        dummy_cfg.tools.download_biorxiv_paper.request_timeout = 10
+        mock_compose.return_value = dummy_cfg
+        mock_initialize.return_value.__enter__.return_value = None
+
+        doi = "10.1101/2025.05.13.653102"
+
+        dummy_response = MagicMock()
+        dummy_response.status_code = 200
+        dummy_response.raise_for_status = MagicMock()
+        dummy_response.json.return_value = {
+            "collection": [
+                {
+                    "title": "Sample BioRxiv Paper",
+                    "authors": "Author One; Author Two",
+                    "abstract": "This is a bioRxiv abstract.",
+                    "date": "2025-04-25",
+                    "doi": doi,
+                    "link": f"https://www.biorxiv.org/content/{doi}.full.pdf"
+                }
+            ]
+        }
+        mock_get.return_value = dummy_response
+
+        tool_input = {"doi": doi, "tool_call_id": "test_tool_id"}
+        result = download_biorxiv_paper.run(tool_input)
+        update = result.update
+
+        self.assertIn("article_data", update)
+        self.assertIn(doi, update["article_data"])
+        metadata = update["article_data"][doi]
+        self.assertEqual(metadata["Title"], "Sample BioRxiv Paper")
+        self.assertEqual(metadata["Authors"], "Author One; Author Two")
+        self.assertEqual(metadata["Abstract"], "This is a bioRxiv abstract.")
+        self.assertEqual(metadata["Publication Date"], "2025-04-25")
+        self.assertEqual(metadata["URL"], f"https://www.biorxiv.org/content/{doi}.full.pdf")
+        self.assertEqual(metadata["pdf_url"], f"https://www.biorxiv.org/content/{doi}.full.pdf")
+        self.assertEqual(metadata["filename"], f"{doi.rsplit('/', maxsplit=1)[-1]}.pdf")
+        self.assertEqual(metadata["source"], "biorxiv")
+        self.assertEqual(metadata["biorxiv_id"], doi)
+
+        self.assertTrue(len(update["messages"]) >= 1)
+        self.assertIsInstance(update["messages"][0], ToolMessage)
+        self.assertIn("Successfully retrieved metadata and PDF URL", update["messages"][0].content)
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.hydra.initialize"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.hydra.compose"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.requests.get"
+    )
+    def test_no_entry_found(self, mock_get, mock_compose, mock_initialize):
+        """Test behavior when no 'entry' is in response."""
+        dummy_cfg = MagicMock()
+        dummy_cfg.tools.download_biorxiv_paper.api_url = "http://dummy.biorxiv.org/api"
+        dummy_cfg.tools.download_biorxiv_paper.request_timeout = 10
+        mock_compose.return_value = dummy_cfg
+        mock_initialize.return_value.__enter__.return_value = None
+
+        dummy_response = MagicMock()
+        dummy_response.status_code = 200
+        dummy_response.raise_for_status = MagicMock()
+        dummy_response.json.return_value = {}  # No entry
+        mock_get.return_value = dummy_response
+
+        doi = "10.1101/2025.05.13.653102"
+        tool_input = {"doi": doi, "tool_call_id": "test_tool_id"}
+
+        with self.assertRaises(ValueError) as context:
+            download_biorxiv_paper.run(tool_input)
+
+        self.assertEqual(str(context.exception), f"No metadata found for DOI: {doi}")
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.hydra.initialize"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.hydra.compose"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.requests.get"
+    )
+    def test_no_pdf_url_found(self, mock_get, mock_compose, mock_initialize):
+        """Test fallback to DOI-based PDF URL construction when 'link' is missing."""
+        dummy_cfg = MagicMock()
+        dummy_cfg.tools.download_biorxiv_paper.api_url = "http://dummy.biorxiv.org/api"
+        dummy_cfg.tools.download_biorxiv_paper.request_timeout = 10
+        mock_compose.return_value = dummy_cfg
+        mock_initialize.return_value.__enter__.return_value = None
+
+        doi = "10.1101/2025.05.13.653102"
+
+        dummy_response = MagicMock()
+        dummy_response.status_code = 200
+        dummy_response.raise_for_status = MagicMock()
+        dummy_response.json.return_value = {
+            "collection": [
+                {
+                    "title": "Sample Biorxiv Paper",
+                    "authors": "Author One; Author Two",
+                    "abstract": "This is a BioRxiv abstract.",
+                    "date": "2025-04-25",
+                    "doi": doi
+                    # 'link' is intentionally omitted
+                }
+            ]
+        }
+        mock_get.return_value = dummy_response
+
+        tool_input = {"doi": doi, "tool_call_id": "test_tool_id"}
+        result = download_biorxiv_paper.run(tool_input)
+        update = result.update
+        metadata = update["article_data"][doi]
+
+        # Assert that the PDF URL was constructed from DOI
+        expected_suffix = doi.rsplit('/', maxsplit=1)[-1]
+        expected_url = f"https://www.biorxiv.org/content/10.1101/{expected_suffix}.full.pdf"
+
+        self.assertEqual(metadata["pdf_url"], expected_url)

aiagents4pharma-1.39.0/aiagents4pharma/talk2scholars/tests/test_paper_download_medrxiv.py

@@ -0,0 +1,151 @@
+"""
+Unit tests for medrXiv paper downloading functionality, including:
+- download_medrxiv_paper tool function.
+"""
+
+import unittest
+from unittest.mock import MagicMock, patch
+from langchain_core.messages import ToolMessage
+
+from aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input import (
+    download_medrxiv_paper,
+)
+
+
+class TestDownloadMedrxivPaper(unittest.TestCase):
+    """Tests for the download_medrxiv_paper tool."""
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.hydra.initialize"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.hydra.compose"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.requests.get"
+    )
+    def test_download_medrxiv_paper_success(self, mock_get, mock_compose, mock_initialize):
+        """Test successful metadata and PDF URL retrieval."""
+        dummy_cfg = MagicMock()
+        dummy_cfg.tools.download_medrxiv_paper.api_url = "http://dummy.medrxiv.org/api"
+        dummy_cfg.tools.download_medrxiv_paper.request_timeout = 10
+        mock_compose.return_value = dummy_cfg
+        mock_initialize.return_value.__enter__.return_value = None
+
+        doi = "10.1101/2025.04.25.25326432"
+
+        dummy_response = MagicMock()
+        dummy_response.status_code = 200
+        dummy_response.raise_for_status = MagicMock()
+        dummy_response.json.return_value = {
+            "collection": [
+                {
+                    "title": "Sample Medrxiv Paper",
+                    "authors": "Author One; Author Two",
+                    "abstract": "This is a medRxiv abstract.",
+                    "date": "2025-04-25",
+                    "doi": doi,
+                    "link": f"https://www.medrxiv.org/content/{doi}.full.pdf"
+                }
+            ]
+        }
+        mock_get.return_value = dummy_response
+
+        tool_input = {"doi": doi, "tool_call_id": "test_tool_id"}
+        result = download_medrxiv_paper.run(tool_input)
+        update = result.update
+
+        self.assertIn("article_data", update)
+        self.assertIn(doi, update["article_data"])
+        metadata = update["article_data"][doi]
+        self.assertEqual(metadata["Title"], "Sample Medrxiv Paper")
+        self.assertEqual(metadata["Authors"], "Author One; Author Two")
+        self.assertEqual(metadata["Abstract"], "This is a medRxiv abstract.")
+        self.assertEqual(metadata["Publication Date"], "2025-04-25")
+        self.assertEqual(metadata["URL"], f"https://www.medrxiv.org/content/{doi}.full.pdf")
+        self.assertEqual(metadata["pdf_url"], f"https://www.medrxiv.org/content/{doi}.full.pdf")
+        self.assertEqual(metadata["filename"], f"{doi.rsplit('/', maxsplit=1)[-1]}.pdf")
+        self.assertEqual(metadata["source"], "medrxiv")
+        self.assertEqual(metadata["medrxiv_id"], doi)
+
+        self.assertTrue(len(update["messages"]) >= 1)
+        self.assertIsInstance(update["messages"][0], ToolMessage)
+        self.assertIn("Successfully retrieved metadata and PDF URL", update["messages"][0].content)
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.hydra.initialize"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.hydra.compose"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.requests.get"
+    )
+    def test_no_entry_found(self, mock_get, mock_compose, mock_initialize):
+        """Test behavior when no 'entry' is in response."""
+        dummy_cfg = MagicMock()
+        dummy_cfg.tools.download_medrxiv_paper.api_url = "http://dummy.medrxiv.org/api"
+        dummy_cfg.tools.download_medrxiv_paper.request_timeout = 10
+        mock_compose.return_value = dummy_cfg
+        mock_initialize.return_value.__enter__.return_value = None
+
+        dummy_response = MagicMock()
+        dummy_response.status_code = 200
+        dummy_response.raise_for_status = MagicMock()
+        dummy_response.json.return_value = {}  # No entry
+        mock_get.return_value = dummy_response
+
+        doi = "10.1101/2025.04.25.25326432"
+        tool_input = {"doi": doi, "tool_call_id": "test_tool_id"}
+
+        with self.assertRaises(ValueError) as context:
+            download_medrxiv_paper.run(tool_input)
+
+        self.assertEqual(str(context.exception), f"No entry found for medRxiv ID {doi}")
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.hydra.initialize"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.hydra.compose"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.requests.get"
+    )
+    def test_no_pdf_url_found(self, mock_get, mock_compose, mock_initialize):
+        """Test fallback to DOI-based PDF URL construction when 'link' is missing."""
+        dummy_cfg = MagicMock()
+        dummy_cfg.tools.download_medrxiv_paper.api_url = "http://dummy.medrxiv.org/api"
+        dummy_cfg.tools.download_medrxiv_paper.request_timeout = 10
+        mock_compose.return_value = dummy_cfg
+        mock_initialize.return_value.__enter__.return_value = None
+
+        doi = "10.1101/2025.04.25.25326432"
+
+        dummy_response = MagicMock()
+        dummy_response.status_code = 200
+        dummy_response.raise_for_status = MagicMock()
+        dummy_response.json.return_value = {
+            "collection": [
+                {
+                    "title": "Sample Medrxiv Paper",
+                    "authors": "Author One; Author Two",
+                    "abstract": "This is a medRxiv abstract.",
+                    "date": "2025-04-25",
+                    "doi": doi
+                    # 'link' is intentionally omitted
+                }
+            ]
+        }
+        mock_get.return_value = dummy_response
+
+        tool_input = {"doi": doi, "tool_call_id": "test_tool_id"}
+        result = download_medrxiv_paper.run(tool_input)
+        update = result.update
+        metadata = update["article_data"][doi]
+
+        # Assert that the PDF URL was constructed from DOI
+        expected_suffix = doi.rsplit('/', maxsplit=1)[-1]
+        expected_url = f"https://www.medrxiv.org/content/10.1101/{expected_suffix}.full.pdf"
+
+        self.assertEqual(metadata["pdf_url"], expected_url)

{aiagents4pharma-1.38.0 → aiagents4pharma-1.39.0}/aiagents4pharma/talk2scholars/tools/paper_download/__init__.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 """
-This package provides modules for fetching and downloading academic papers from arXiv.
+This package provides modules for fetching and downloading academic papers from arXiv,
+biorxiv and medrxiv.
 """
 
 # Import modules
@@ -8,4 +9,6 @@ from . import download_arxiv_input
 
 __all__ = [
     "download_arxiv_input",
+    "download_biorxiv_input",
+    "download_medrxiv_input",
 ]

aiagents4pharma-1.39.0/aiagents4pharma/talk2scholars/tools/paper_download/download_biorxiv_input.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+Tool for downloading bioRxiv paper metadata and retrieving the PDF URL.
+"""
+
+import logging
+from typing import Annotated, Any
+
+import hydra
+import requests
+from langchain_core.messages import ToolMessage
+from langchain_core.tools import tool
+from langchain_core.tools.base import InjectedToolCallId
+from langgraph.types import Command
+from pydantic import BaseModel, Field
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class DownloadBiorxivPaperInput(BaseModel):
+    """Input schema for the bioRxiv paper download tool."""
+
+    doi: str = Field(description=
+    """The bioRxiv DOI, from search_helper or multi_helper or single_helper, 
+    used to retrieve the paper details and PDF URL."""
+    )
+    logger.info("DOI Received: %s", doi)
+    tool_call_id: Annotated[str, InjectedToolCallId]
+
+def fetch_biorxiv_metadata(doi: str, api_url: str, request_timeout: int) -> dict:
+    """
+    Fetch metadata for a bioRxiv paper using its DOI and extract relevant fields.
+    
+    Parameters:
+        doi (str): The DOI of the bioRxiv paper.
+    
+    Returns:
+        dict: A dictionary containing the title, authors, abstract, publication date, and URLs.
+    """
+    # Strip any version suffix (e.g., v1) since bioRxiv's API is version-sensitive
+    clean_doi = doi.split("v")[0]
+
+    api_url = f"{api_url}{clean_doi}"
+    logger.info("Fetching metadata from api url: %s", api_url)
+    response = requests.get(api_url, timeout=request_timeout)
+    response.raise_for_status()
+
+    data = response.json()
+    if not data.get("collection"):
+        raise ValueError(f"No metadata found for DOI: {doi}")
+
+    data = response.json()
+
+    return data["collection"][0]
+
+def extract_metadata(paper: dict, doi: str) -> dict:
+    """
+    Extract relevant metadata fields from a bioRxiv paper entry.
+    """
+    title = paper.get("title", "")
+    authors = paper.get("authors", "")
+    abstract = paper.get("abstract", "")
+    pub_date = paper.get("date", "")
+    doi_suffix = paper.get("doi", "").split("10.1101/")[-1]
+    pdf_url = f"https://www.biorxiv.org/content/10.1101/{doi_suffix}.full.pdf"
+    logger.info("PDF URL: %s", pdf_url)
+    return {
+        "Title": title,
+        "Authors": authors,
+        "Abstract": abstract,
+        "Publication Date": pub_date,
+        "URL": pdf_url,
+        "pdf_url": pdf_url,
+        "filename": f"{doi_suffix}.pdf",
+        "source": "biorxiv",
+        "biorxiv_id": doi
+    }
+
+@tool(args_schema=DownloadBiorxivPaperInput, parse_docstring=True)
+def download_biorxiv_paper(
+    doi: str,
+    tool_call_id: Annotated[str, InjectedToolCallId],
+) -> Command[Any]:
+    """
+    Get metadata and PDF URL for a bioRxiv paper using its DOI.
+    """
+    logger.info("Fetching metadata from bioRxiv for DOI: %s", doi)
+
+    # Load configuration
+    with hydra.initialize(version_base=None, config_path="../../configs"):
+        cfg = hydra.compose(
+            config_name="config", overrides=["tools/download_biorxiv_paper=default"]
+        )
+        api_url = cfg.tools.download_biorxiv_paper.api_url
+        request_timeout = cfg.tools.download_biorxiv_paper.request_timeout
+        logger.info("API URL: %s", api_url)
+        logger.info("Request Timeout: %s", request_timeout)
+
+    # Fetch metadata
+    raw_data = fetch_biorxiv_metadata(doi, api_url, request_timeout)
+    metadata = extract_metadata(raw_data, doi)
+    article_data = {doi: metadata}
+    content = f"Successfully retrieved metadata and PDF URL for bioRxiv DOI {doi}"
+
+    return Command(
+        update={
+            "article_data": article_data,
+            "messages": [ToolMessage(content=content, tool_call_id=tool_call_id)],
+        }
+    )

aiagents4pharma-1.39.0/aiagents4pharma/talk2scholars/tools/paper_download/download_medrxiv_input.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+Tool for downloading medRxiv paper metadata and retrieving the PDF URL.
+"""
+
+import logging
+from typing import Annotated, Any
+
+import hydra
+import requests
+from langchain_core.messages import ToolMessage
+from langchain_core.tools import tool
+from langchain_core.tools.base import InjectedToolCallId
+from langgraph.types import Command
+from pydantic import BaseModel, Field
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class DownloadMedrxivPaperInput(BaseModel):
+    """Input schema for the medRxiv paper download tool."""
+
+    doi: str = Field(description=
+    """The medRxiv DOI, from search_helper or multi_helper or single_helper, 
+    used to retrieve the paper details and PDF URL."""
+    )
+    logger.info("DOI Received: %s", doi)
+    tool_call_id: Annotated[str, InjectedToolCallId]
+
+# Fetching raw metadata from medRxiv API for a given DOI
+def fetch_medrxiv_metadata(doi: str, api_url: str, request_timeout: int) -> dict:
+    """
+    Fetch metadata for a medRxiv paper using its DOI and extract relevant fields.
+
+    Parameters:
+        doi (str): The DOI of the medRxiv paper.
+
+    Returns:
+        dict: A dictionary containing the title, authors, abstract, publication date, and URLs.
+    """
+    # Strip any version suffix (e.g., v1) since bioRxiv's API is version-sensitive
+    clean_doi = doi.split("v")[0]
+
+    api_url = f"{api_url}{clean_doi}"
+    logger.info("Fetching metadata from api url: %s", api_url)
+    response = requests.get(api_url, timeout=request_timeout)
+    response.raise_for_status()
+
+    data = response.json()
+    if not data.get("collection"):
+        raise ValueError(f"No entry found for medRxiv ID {doi}")
+
+    return data["collection"][0]
+
+# Extracting relevant metadata fields from the raw data
+def extract_metadata(paper: dict, doi: str) -> dict:
+    """
+    Extract relevant metadata fields from a medRxiv paper entry.
+    """
+    title = paper.get("title", "")
+    authors = paper.get("authors", "")
+    abstract = paper.get("abstract", "")
+    pub_date = paper.get("date", "")
+    doi_suffix = paper.get("doi", "").split("10.1101/")[-1]
+    pdf_url = f"https://www.medrxiv.org/content/10.1101/{doi_suffix}.full.pdf"
+    logger.info("PDF URL: %s", pdf_url)
+    return {
+        "Title": title,
+        "Authors": authors,
+        "Abstract": abstract,
+        "Publication Date": pub_date,
+        "URL": pdf_url,
+        "pdf_url": pdf_url,
+        "filename": f"{doi_suffix}.pdf",
+        "source": "medrxiv",
+        "medrxiv_id": doi
+    }
+
+# Tool to download medRxiv paper metadata and PDF URL
+@tool(args_schema=DownloadMedrxivPaperInput, parse_docstring=True)
+def download_medrxiv_paper(
+    doi: str,
+    tool_call_id: Annotated[str, InjectedToolCallId],
+) -> Command[Any]:
+    """
+    Get metadata and PDF URL for a medRxiv paper using its doi or medrxiv id.
+    """
+    logger.info("Fetching metadata from medRxiv for DOI: %s", doi)
+
+    # Load configuration
+    with hydra.initialize(version_base=None, config_path="../../configs"):
+        cfg = hydra.compose(
+            config_name="config", overrides=["tools/download_medrxiv_paper=default"]
+        )
+        api_url = cfg.tools.download_medrxiv_paper.api_url
+        request_timeout = cfg.tools.download_medrxiv_paper.request_timeout
+        logger.info("API URL: %s", api_url)
+
+    raw_data = fetch_medrxiv_metadata(doi, api_url, request_timeout)
+    metadata = extract_metadata(raw_data, doi)
+    article_data = {doi: metadata}
+
+    content = f"Successfully retrieved metadata and PDF URL for medRxiv DOI {doi}"
+
+    return Command(
+        update={
+            "article_data": article_data,
+            "messages": [ToolMessage(content=content, tool_call_id=tool_call_id)],
+        }
+    )

{aiagents4pharma-1.38.0 → aiagents4pharma-1.39.0}/aiagents4pharma/talk2scholars/tools/pdf/question_and_answer.py

@@ -500,8 +500,27 @@ def question_and_answer(
         if isinstance(paper, dict)
     )
 
+    has_biorxiv_papers = any(
+        paper.get("source") == "biorxiv"
+        for paper in article_data.values()
+        if isinstance(paper, dict)
+    )
+
+    has_medrxiv_papers = any(
+        paper.get("source") == "medrxiv"
+        for paper in article_data.values()
+        if isinstance(paper, dict)
+    )
+
     # Choose papers to use
     selected_paper_ids = []
+    has_combimed_papers = (
+        has_uploaded_papers
+        or has_zotero_papers
+        or has_arxiv_papers
+        or has_biorxiv_papers
+        or has_medrxiv_papers
+    )
 
     if paper_ids:
         # Use explicitly specified papers
@@ -515,7 +534,7 @@ def question_and_answer(
                 "%s: None of the provided paper_ids %s were found", call_id, paper_ids
             )
 
-    elif use_all_papers or has_uploaded_papers or has_zotero_papers or has_arxiv_papers:
+    elif use_all_papers or has_combimed_papers:
         # Use all available papers if explicitly requested or if we have papers from any source
         selected_paper_ids = list(article_data.keys())
         logger.info(

{aiagents4pharma-1.38.0 → aiagents4pharma-1.39.0}/aiagents4pharma/talk2scholars/tools/s2/utils/multi_helper.py

@@ -143,6 +143,7 @@ class MultiPaperRecData:
                 ],
                 "URL": paper.get("url", "N/A"),
                 "arxiv_id": paper.get("externalIds", {}).get("ArXiv", "N/A"),
+                "doi": paper.get("externalIds", {}).get("DOI", "N/A"),
             }
             for paper in self.recommendations
             if paper.get("title") and paper.get("authors")
@@ -158,6 +159,7 @@ class MultiPaperRecData:
                 f"{i+1}. {paper['Title']} ({paper['Year']}; "
                 f"semantic_scholar_paper_id: {paper['semantic_scholar_paper_id']}; "
                 f"arXiv ID: {paper['arxiv_id']})"
+                f"doi: {paper['doi']})"
                 for i, paper in enumerate(top_papers)
             ]
         )