text within this directly under directly under abstract, but abstract_element itself has text (less common)
+ elif abstract_element.text and abstract_element.text.strip():
+ abstract_text = abstract_element.text.strip()
+
+ abstract = abstract_text # Assign to the variable used later
+
+
+ # Extract publication date
+ pub_date_node = article_node.find(".//pub-date[@pub-type='epub']") # Prefer electronic pub date
+ if pub_date_node is None: # Fallback to print or other pub-types if epub not found
+ pub_date_node = article_node.find(".//pub-date[@pub-type='ppub']")
+ if pub_date_node is None:
+ pub_date_node = article_node.find(".//pub-date") # Generic fallback
+
+ year, month, day = "N/A", "N/A", "N/A"
+ if pub_date_node is not None:
+ year_node = pub_date_node.find("./year") # Use relative path
+ month_node = pub_date_node.find("./month")
+ day_node = pub_date_node.find("./day")
+ year = year_node.text if year_node is not None and year_node.text else "N/A"
+ month = month_node.text if month_node is not None and month_node.text else "01" # Default month/day
+ day = day_node.text if day_node is not None and day_node.text else "01"
+
+ try:
+ # Handle cases where year might be invalid
+ if year == "N/A" or not year.isdigit():
+ year_int = 1900 # Default year
+ else:
+ year_int = int(year)
+
+ if month == "N/A" or not month.isdigit() or not (1 <= int(month) <= 12):
+ month_int = 1
+ else:
+ month_int = int(month)
+
+ if day == "N/A" or not day.isdigit() or not (1 <= int(day) <= 31):
+ day_int = 1
+ else:
+ day_int = int(day)
+
+ published = datetime(year_int, month_int, day_int)
+ except ValueError:
+ published = datetime(1900, 1, 1) # Default for parsing errors
+
+ # Extract DOI
+ doi_node = article_node.find(".//article-id[@pub-id-type='doi']")
+ doi = doi_node.text if doi_node is not None and doi_node.text else ""
+
+ papers.append(Paper(
+ paper_id=pmcid, # Use PMCID as the primary ID
+ title=title,
+ authors=authors,
+ abstract=abstract,
+ url=f"https://www.ncbi.nlm.nih.gov/pmc/articles/PMC{pmcid}/", # PMC uses PMCID in URL
+ pdf_url=self.PMC_PDF_URL.format(pmcid=f"PMC{pmcid}"),
+ published_date=published,
+ updated_date=published, # Assuming same as published for now
+ source='pmc',
+ categories=[], # PMC API doesn't easily provide categories
+ keywords=[], # PMC API doesn't easily provide keywords
+ doi=doi
+ ))
+ except Exception as e:
+ print(f"Error parsing PMC article XML (PMCID: {pmcid if 'pmcid' in locals() else 'unknown'}): {e}")
+ return papers
+
+ def download_pdf(self, paper_id: str, save_path: str = "./downloads") -> str:
+ """Download the PDF for a PMC paper."""
+ if not paper_id.startswith("PMC"):
+ paper_id = f"PMC{paper_id}"
+
+ pdf_url = self.PMC_PDF_URL.format(pmcid=paper_id)
+
+ os.makedirs(save_path, exist_ok=True)
+ file_path = os.path.join(save_path, f"{paper_id}.pdf")
+
+ try:
+ response = requests.get(pdf_url, stream=True)
+ response.raise_for_status()
+ with open(file_path, 'wb') as f:
+ for chunk in response.iter_content(chunk_size=8192):
+ f.write(chunk)
+ return file_path
+ except requests.RequestException as e:
+ raise ConnectionError(f"Failed to download PDF from {pdf_url}: {e}")
+
+ def read_paper(self, paper_id: str, save_path: str = "./downloads") -> str:
+ """Download and read text from a PMC paper's PDF."""
+ pdf_path = self.download_pdf(paper_id, save_path)
+
+ try:
+ with open(pdf_path, 'rb') as f:
+ reader = PyPDF2.PdfReader(f)
+ text = ""
+ for page_num in range(len(reader.pages)):
+ text += reader.pages[page_num].extract_text() or ""
+ return text
+ except Exception as e:
+ print(f"Error reading PDF {pdf_path}: {e}")
+ return "" # Return empty string on error
+
+if __name__ == "__main__":
+ searcher = PMCSearcher()
+
+ print("Testing PMC search functionality...")
+ query = "crispr gene editing"
+ max_results = 3
+ 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}. ID: {paper.paper_id} - {paper.title}")
+ print(f" Authors: {', '.join(paper.authors)}")
+ print(f" DOI: {paper.doi}")
+ print(f" URL: {paper.url}")
+ print(f" PDF URL: {paper.pdf_url}\n")
+
+ if papers:
+ # Test PDF download and read
+ test_paper = papers[0]
+ print(f"\nTesting PDF download and read for PMCID: {test_paper.paper_id}")
+ try:
+ pdf_file_path = searcher.download_pdf(test_paper.paper_id)
+ print(f"PDF downloaded to: {pdf_file_path}")
+
+ # Check if file exists and is not empty
+ if os.path.exists(pdf_file_path) and os.path.getsize(pdf_file_path) > 0:
+ print("PDF file seems valid.")
+ paper_text = searcher.read_paper(test_paper.paper_id)
+ if paper_text:
+ print(f"Successfully read paper. First 500 chars:\n{paper_text[:500]}...")
+ else:
+ print("Could not extract text from PDF, or PDF was empty.")
+ else:
+ print(f"PDF file at {pdf_file_path} is missing or empty.")
+
+ except ConnectionError as e:
+ print(f"Connection error during PDF download/read test: {e}")
+ except Exception as e:
+ print(f"Error during PDF download/read test: {e}")
+ else:
+ print("No papers found to test download/read functionality.")
+
+ except Exception as e:
+ print(f"Error during PMC search test: {e}")
diff --git a/paper_search_mcp/server.py b/paper_search_mcp/server.py
index dcaba0b..77a7e8f 100644
--- a/paper_search_mcp/server.py
+++ b/paper_search_mcp/server.py
@@ -10,6 +10,7 @@
from .academic_platforms.iacr import IACRSearcher
from .academic_platforms.semantic import SemanticSearcher
from .academic_platforms.scopus import ScopusSearcher
+from .academic_platforms.pmc import PMCSearcher # Added PMC
# from .academic_platforms.hub import SciHubSearcher
from .paper import Paper
@@ -23,6 +24,7 @@
biorxiv_searcher = BioRxivSearcher()
medrxiv_searcher = MedRxivSearcher()
google_scholar_searcher = GoogleScholarSearcher()
+pmc_searcher = PMCSearcher() # Added PMC
import os # Import os module
iacr_searcher = IACRSearcher()
@@ -401,6 +403,58 @@ async def read_scopus_paper(paper_id: str, save_path: str = "./downloads") -> st
print(f"Error during Scopus read attempt for {paper_id}: {e}")
return f"An unexpected error occurred: {e}"
+@mcp.tool()
+async def search_pmc(query: str, max_results: int = 10) -> List[Dict]:
+ """Search academic papers from PubMed Central (PMC).
+
+ Args:
+ query: Search query string (e.g., 'crispr gene editing').
+ max_results: Maximum number of papers to return (default: 10).
+ Returns:
+ List of paper metadata in dictionary format.
+ """
+ papers = await async_search(pmc_searcher, query, max_results)
+ return papers if papers else []
+
+@mcp.tool()
+async def download_pmc(paper_id: str, save_path: str = "./downloads") -> str:
+ """Download PDF of a PubMed Central (PMC) paper.
+
+ Args:
+ paper_id: PMC paper ID (e.g., 'PMC3539183' or '3539183').
+ save_path: Directory to save the PDF (default: './downloads').
+ Returns:
+ Path to the downloaded PDF file or an error message.
+ """
+ try:
+ # PMCSearcher.download_pdf is synchronous, adapt if needed or call directly
+ # For simplicity, calling it directly assuming it's okay in this context
+ # If strict async is required, it should be wrapped like other searchers.
+ return pmc_searcher.download_pdf(paper_id, save_path)
+ except ConnectionError as e:
+ return str(e)
+ except Exception as e:
+ print(f"Error downloading PMC paper {paper_id}: {e}")
+ return f"An unexpected error occurred during PMC download: {e}"
+
+@mcp.tool()
+async def read_pmc_paper(paper_id: str, save_path: str = "./downloads") -> str:
+ """Read and extract text content from a PubMed Central (PMC) paper PDF.
+
+ Args:
+ paper_id: PMC paper ID (e.g., 'PMC3539183' or '3539183').
+ save_path: Directory where the PDF is/will be saved (default: './downloads').
+ Returns:
+ str: The extracted text content of the paper or an error message.
+ """
+ try:
+ # PMCSearcher.read_paper is synchronous
+ return pmc_searcher.read_paper(paper_id, save_path)
+ except ConnectionError as e: # Catch connection errors from download_pdf
+ return str(e)
+ except Exception as e:
+ print(f"Error reading PMC paper {paper_id}: {e}")
+ return f"An unexpected error occurred during PMC paper reading: {e}"
if __name__ == "__main__":
mcp.run(transport="stdio")
diff --git a/tests/test_pmc.py b/tests/test_pmc.py
new file mode 100644
index 0000000..0a1ce33
--- /dev/null
+++ b/tests/test_pmc.py
@@ -0,0 +1,221 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import os
+import requests # Added import
+from datetime import datetime
+
+from paper_search_mcp.academic_platforms.pmc import PMCSearcher
+from paper_search_mcp.paper import Paper
+
+class TestPMCSearcher(unittest.TestCase):
+
+ def setUp(self):
+ self.searcher = PMCSearcher()
+ self.test_downloads_dir = "test_downloads_pmc"
+ os.makedirs(self.test_downloads_dir, exist_ok=True)
+
+ def tearDown(self):
+ # Clean up created files and directory
+ if os.path.exists(self.test_downloads_dir):
+ for f in os.listdir(self.test_downloads_dir):
+ os.remove(os.path.join(self.test_downloads_dir, f))
+ os.rmdir(self.test_downloads_dir)
+
+ @patch('paper_search_mcp.academic_platforms.pmc.requests.get')
+ def test_search_success(self, mock_get):
+ # Mock ESearch response
+ mock_esearch_response = MagicMock()
+ mock_esearch_response.status_code = 200
+ mock_esearch_response.content = b"""
+ This is abstract 1. Background info. Results here.