all-in-mcp 0.2.2__py3-none-any.whl → 0.2.5__py3-none-any.whl

all_in_mcp/academic_platforms/__init__.py

@@ -1,6 +1,7 @@
 # all_in_mcp/academic_platforms/__init__.py
 from .base import PaperSource
 from .cryptobib import CryptoBibSearcher
+from .google_scholar import GoogleScholarSearcher
 from .iacr import IACRSearcher
 
-__all__ = ["PaperSource", "CryptoBibSearcher", "IACRSearcher"]
+__all__ = ["CryptoBibSearcher", "GoogleScholarSearcher", "IACRSearcher", "PaperSource"]

all_in_mcp/academic_platforms/crossref.py

@@ -0,0 +1,328 @@
+# all_in_mcp/academic_platforms/crossref.py
+import logging
+from datetime import datetime
+from typing import Optional
+from urllib.parse import quote_plus
+
+import httpx
+
+from ..paper import Paper
+from .base import PaperSource
+
+logger = logging.getLogger(__name__)
+
+
+class CrossrefSearcher(PaperSource):
+    """Crossref API paper search implementation"""
+
+    BASE_URL = "https://api.crossref.org"
+    WORKS_ENDPOINT = f"{BASE_URL}/works"
+
+    def __init__(self, email: Optional[str] = None):
+        """
+        Initialize Crossref searcher
+
+        Args:
+            email: Optional email for polite API usage (recommended by Crossref)
+        """
+        self.email = email
+        self.client = httpx.Client(timeout=30.0)
+
+    def _get_headers(self) -> dict:
+        """Get headers for API requests"""
+        headers = {
+            "User-Agent": "all-in-mcp/0.1.0 (https://github.com/user/all-in-mcp)"
+        }
+        if self.email:
+            headers["User-Agent"] += f" (mailto:{self.email})"
+        return headers
+
+    def _parse_date(self, date_parts: list) -> Optional[datetime]:
+        """Parse Crossref date parts into datetime"""
+        if not date_parts or not isinstance(date_parts, list):
+            return None
+
+        try:
+            # Crossref provides date as [[year, month, day]] or [[year, month]] or [[year]]
+            if len(date_parts) > 0 and isinstance(date_parts[0], list):
+                parts = date_parts[0]
+                year = parts[0] if len(parts) > 0 else 1
+                month = parts[1] if len(parts) > 1 else 1
+                day = parts[2] if len(parts) > 2 else 1
+                return datetime(year, month, day)
+        except (ValueError, IndexError, TypeError):
+            pass
+        return None
+
+    def _extract_authors(self, authors_data: list) -> list[str]:
+        """Extract author names from Crossref author data"""
+        authors = []
+        for author in authors_data or []:
+            if isinstance(author, dict):
+                given = author.get("given", "")
+                family = author.get("family", "")
+                if given and family:
+                    authors.append(f"{given} {family}")
+                elif family:
+                    authors.append(family)
+                elif given:
+                    authors.append(given)
+        return authors
+
+    def _parse_work(self, work: dict) -> Optional[Paper]:
+        """Parse a single work from Crossref API response"""
+        try:
+            # Extract basic information
+            title_list = work.get("title", [])
+            title = title_list[0] if title_list else ""
+
+            if not title:
+                return None
+
+            doi = work.get("DOI", "")
+            paper_id = doi or work.get("URL", "")
+
+            # Extract authors
+            authors = self._extract_authors(work.get("author", []))
+
+            # Extract abstract
+            abstract = work.get("abstract", "")
+            if abstract:
+                # Remove HTML tags if present
+                import re
+
+                abstract = re.sub(r"<[^>]+>", "", abstract)
+
+            # Extract publication date
+            published_date = (
+                self._parse_date(work.get("published-print", {}).get("date-parts"))
+                or self._parse_date(work.get("published-online", {}).get("date-parts"))
+                or self._parse_date(work.get("created", {}).get("date-parts"))
+            )
+
+            # Extract URLs
+            url = work.get("URL", "")
+            pdf_url = ""
+
+            # Look for PDF in links
+            links = work.get("link", [])
+            for link in links:
+                if link.get("content-type") == "application/pdf":
+                    pdf_url = link.get("URL", "")
+                    break
+
+            # Extract additional metadata
+            container_title = work.get("container-title", [])
+            journal = container_title[0] if container_title else ""
+
+            volume = work.get("volume", "")
+            issue = work.get("issue", "")
+            pages = work.get("page", "")
+
+            # Extract categories/subjects
+            categories = []
+            subjects = work.get("subject", [])
+            if subjects:
+                categories.extend(subjects)
+
+            # Citation count (if available)
+            citations = work.get("is-referenced-by-count", 0)
+
+            # Build extra metadata
+            extra = {
+                "journal": journal,
+                "volume": volume,
+                "issue": issue,
+                "pages": pages,
+                "type": work.get("type", ""),
+                "publisher": work.get("publisher", ""),
+                "issn": work.get("ISSN", []),
+                "isbn": work.get("ISBN", []),
+            }
+
+            # Remove empty values from extra
+            extra = {k: v for k, v in extra.items() if v}
+
+            return Paper(
+                paper_id=paper_id,
+                title=title,
+                authors=authors,
+                abstract=abstract,
+                doi=doi,
+                published_date=published_date or datetime(1900, 1, 1),
+                pdf_url=pdf_url,
+                url=url,
+                source="crossref",
+                categories=categories,
+                citations=citations,
+                extra=extra,
+            )
+
+        except Exception as e:
+            logger.error(f"Error parsing Crossref work: {e}")
+            return None
+
+    def search(
+        self,
+        query: str,
+        max_results: int = 10,
+        year_min: Optional[int] = None,
+        year_max: Optional[int] = None,
+        sort_by: str = "relevance",
+        **kwargs,
+    ) -> list[Paper]:
+        """
+        Search for papers using Crossref API
+
+        Args:
+            query: Search query string
+            max_results: Maximum number of results to return
+            year_min: Minimum publication year
+            year_max: Maximum publication year
+            sort_by: Sort order (relevance, published, indexed, updated)
+        """
+        if not query.strip():
+            return []
+
+        try:
+            params = {
+                "query": query,
+                "rows": min(max_results, 1000),  # Crossref max is 1000
+                "sort": sort_by,
+                "select": "DOI,title,author,abstract,published-print,published-online,created,URL,container-title,volume,issue,page,subject,is-referenced-by-count,type,publisher,ISSN,ISBN,link",
+            }
+
+            # Add year filters if specified
+            filters = []
+            if year_min:
+                filters.append(f"from-pub-date:{year_min}")
+            if year_max:
+                filters.append(f"until-pub-date:{year_max}")
+
+            if filters:
+                params["filter"] = ",".join(filters)
+
+            response = self.client.get(
+                self.WORKS_ENDPOINT, params=params, headers=self._get_headers()
+            )
+            response.raise_for_status()
+
+            data = response.json()
+            works = data.get("message", {}).get("items", [])
+
+            papers = []
+            for work in works:
+                paper = self._parse_work(work)
+                if paper:
+                    papers.append(paper)
+
+            return papers[:max_results]
+
+        except Exception as e:
+            logger.error(f"Error searching Crossref: {e}")
+            return []
+
+    def download_pdf(self, paper_id: str, save_path: str) -> str:
+        """
+        Download PDF for a paper (limited functionality for Crossref)
+
+        Note: Crossref is primarily a metadata service. PDF downloads
+        depend on publisher policies and may not always be available.
+        """
+        if not paper_id:
+            return "Error: paper_id is required"
+
+        try:
+            # If paper_id is a DOI, try to get work details first
+            if not paper_id.startswith("http"):
+                work_url = f"{self.WORKS_ENDPOINT}/{quote_plus(paper_id)}"
+                response = self.client.get(work_url, headers=self._get_headers())
+                response.raise_for_status()
+
+                work_data = response.json()
+                work = work_data.get("message", {})
+
+                # Look for PDF link
+                links = work.get("link", [])
+                pdf_url = None
+                for link in links:
+                    if link.get("content-type") == "application/pdf":
+                        pdf_url = link.get("URL")
+                        break
+
+                if not pdf_url:
+                    return f"Error: No PDF link found for DOI {paper_id}. Crossref provides metadata; PDFs are hosted by publishers."
+            else:
+                pdf_url = paper_id
+
+            # Attempt to download PDF
+            from pathlib import Path
+
+            save_path_obj = Path(save_path)
+            save_path_obj.mkdir(parents=True, exist_ok=True)
+
+            # Create filename from DOI or URL
+            if paper_id.startswith("10."):
+                filename = (
+                    f"crossref_{paper_id.replace('/', '_').replace('.', '_')}.pdf"
+                )
+            else:
+                filename = f"crossref_paper_{hash(paper_id) % 10000}.pdf"
+
+            file_path = save_path_obj / filename
+
+            pdf_response = self.client.get(pdf_url, headers=self._get_headers())
+            pdf_response.raise_for_status()
+
+            with open(file_path, "wb") as f:
+                f.write(pdf_response.content)
+
+            return str(file_path)
+
+        except Exception as e:
+            return f"Error downloading PDF: {e}"
+
+    def read_paper(self, paper_id: str, save_path: str) -> str:
+        """
+        Read paper text (downloads PDF first if needed)
+
+        Note: Success depends on PDF availability from publishers
+        """
+        if not paper_id:
+            return "Error: paper_id is required"
+
+        try:
+            # First try to download the PDF
+            pdf_path = self.download_pdf(paper_id, save_path)
+
+            if pdf_path.startswith("Error"):
+                return pdf_path
+
+            # Read the PDF using the existing read_pdf function
+            from ..paper import read_pdf
+
+            return read_pdf(pdf_path)
+
+        except Exception as e:
+            return f"Error reading paper: {e}"
+
+    def search_by_doi(self, doi: str) -> Optional[Paper]:
+        """Search for a specific paper by DOI"""
+        try:
+            work_url = f"{self.WORKS_ENDPOINT}/{quote_plus(doi)}"
+            response = self.client.get(work_url, headers=self._get_headers())
+            response.raise_for_status()
+
+            data = response.json()
+            work = data.get("message", {})
+
+            return self._parse_work(work)
+
+        except Exception as e:
+            logger.error(f"Error searching by DOI {doi}: {e}")
+            return None
+
+    def __del__(self):
+        """Clean up HTTP client"""
+        if hasattr(self, "client"):
+            self.client.close()

all_in_mcp/academic_platforms/cryptobib.py

@@ -1,6 +1,5 @@
 # all_in_mcp/academic_platforms/cryptobib.py
 import logging
-import os
 import random
 import re
 from datetime import datetime
@@ -118,7 +117,7 @@ class CryptoBibSearcher(PaperSource):
 
             # Extract fields using a more robust approach
             # First, normalize the text by removing extra whitespace
-            normalized_text = re.sub(r"\s+", " ", bibtex_text)
+            re.sub(r"\s+", " ", bibtex_text)
 
             # Extract fields with better pattern matching
             field_dict = {}
@@ -263,7 +262,7 @@ class CryptoBibSearcher(PaperSource):
             # Convert query to lowercase for case-insensitive search
             query_lower = query.lower()
 
-            with open(self.bib_file_path, "r", encoding="utf-8") as f:
+            with open(self.bib_file_path, encoding="utf-8") as f:
                 for line_num, line in enumerate(f, 1):
                     # Check if this is the start of a new entry
                     if line.strip().startswith("@") and not in_entry:
@@ -395,10 +394,10 @@ class CryptoBibSearcher(PaperSource):
             in_entry = False
             brace_count = 0
 
-            with open(self.bib_file_path, "r", encoding="utf-8") as f:
+            with open(self.bib_file_path, encoding="utf-8") as f:
                 for line in f:
                     # Check if this is the start of the entry we're looking for
-                    if line.strip().startswith(f"@") and entry_key in line:
+                    if line.strip().startswith("@") and entry_key in line:
                         current_entry = line
                         in_entry = True
                         brace_count = line.count("{") - line.count("}")

all_in_mcp/academic_platforms/google_scholar.py

@@ -0,0 +1,245 @@
+# all_in_mcp/academic_platforms/google_scholar.py
+import logging
+import random
+import time
+from datetime import datetime
+from typing import Optional
+
+import requests
+from bs4 import BeautifulSoup
+
+from ..paper import Paper
+from .base import PaperSource
+
+logger = logging.getLogger(__name__)
+
+
+class GoogleScholarSearcher(PaperSource):
+    """Google Scholar paper search implementation"""
+
+    SCHOLAR_URL = "https://scholar.google.com/scholar"
+    BROWSERS = [
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:89.0) Gecko/20100101 Firefox/89.0",
+    ]
+
+    def __init__(self):
+        """Initialize Google Scholar searcher"""
+        self._setup_session()
+
+    def _setup_session(self):
+        """Initialize session with random user agent"""
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "User-Agent": random.choice(self.BROWSERS),
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                "Accept-Language": "en-US,en;q=0.9",
+                "Accept-Encoding": "gzip, deflate",
+                "DNT": "1",
+                "Connection": "keep-alive",
+                "Upgrade-Insecure-Requests": "1",
+            }
+        )
+
+    def _extract_year(self, text: str) -> Optional[int]:
+        """Extract publication year from text"""
+        words = text.replace(",", " ").replace("-", " ").split()
+        for word in words:
+            if word.isdigit() and 1900 <= int(word) <= datetime.now().year:
+                return int(word)
+        return None
+
+    def _extract_citations(self, item) -> int:
+        """Extract citation count from paper item"""
+        try:
+            citation_elem = item.find("div", class_="gs_fl")
+            if citation_elem:
+                citation_link = citation_elem.find(
+                    "a", string=lambda text: text and "Cited by" in text
+                )
+                if citation_link:
+                    citation_text = citation_link.get_text()
+                    # Extract number from "Cited by X" text
+                    citation_num = "".join(filter(str.isdigit, citation_text))
+                    return int(citation_num) if citation_num else 0
+            return 0
+        except Exception:
+            return 0
+
+    def _parse_paper(self, item) -> Optional[Paper]:
+        """Parse a single paper entry from HTML"""
+        try:
+            # Extract main paper elements
+            title_elem = item.find("h3", class_="gs_rt")
+            info_elem = item.find("div", class_="gs_a")
+            abstract_elem = item.find("div", class_="gs_rs")
+
+            if not title_elem or not info_elem:
+                return None
+
+            # Process title and URL
+            title_text = title_elem.get_text(strip=True)
+            # Remove common prefixes
+            title = (
+                title_text.replace("[PDF]", "")
+                .replace("[HTML]", "")
+                .replace("[BOOK]", "")
+                .strip()
+            )
+
+            link = title_elem.find("a", href=True)
+            url = link["href"] if link else ""
+
+            # Process author and publication info
+            info_text = info_elem.get_text()
+            info_parts = info_text.split(" - ")
+
+            # Extract authors (usually the first part before the first dash)
+            authors_text = info_parts[0] if info_parts else ""
+            authors = [a.strip() for a in authors_text.split(",") if a.strip()]
+
+            # Extract year from the info text
+            year = self._extract_year(info_text)
+
+            # Extract abstract
+            abstract = abstract_elem.get_text(strip=True) if abstract_elem else ""
+
+            # Extract citations
+            citations = self._extract_citations(item)
+
+            # Generate a paper ID based on the URL or title
+            paper_id = f"gs_{abs(hash(url if url else title))}"
+
+            # Create paper object
+            return Paper(
+                paper_id=paper_id,
+                title=title,
+                authors=authors,
+                abstract=abstract,
+                url=url,
+                pdf_url="",  # Google Scholar doesn't provide direct PDF links
+                published_date=datetime(year, 1, 1) if year else datetime.now(),
+                updated_date=None,
+                source="google_scholar",
+                categories=[],
+                keywords=[],
+                doi="",
+                citations=citations,
+                references=[],
+                extra={"info_text": info_text},
+            )
+        except Exception as e:
+            logger.warning(f"Failed to parse paper: {e}")
+            return None
+
+    def search(self, query: str, max_results: int = 10, **kwargs) -> list[Paper]:
+        """
+        Search Google Scholar for papers
+
+        Args:
+            query: Search query string
+            max_results: Maximum number of results to return
+            **kwargs: Additional search parameters (e.g., year_low, year_high)
+
+        Returns:
+            List of Paper objects
+        """
+        papers = []
+        start = 0
+        results_per_page = min(10, max_results)
+
+        # Extract additional parameters
+        year_low = kwargs.get("year_low")
+        year_high = kwargs.get("year_high")
+
+        while len(papers) < max_results:
+            try:
+                # Construct search parameters
+                params = {
+                    "q": query,
+                    "start": start,
+                    "hl": "en",
+                    "as_sdt": "0,5",  # Include articles and citations
+                    "num": results_per_page,
+                }
+
+                # Add year filters if provided
+                if year_low:
+                    params["as_ylo"] = year_low
+                if year_high:
+                    params["as_yhi"] = year_high
+
+                # Make request with random delay to avoid rate limiting
+                time.sleep(random.uniform(1.0, 3.0))
+                response = self.session.get(self.SCHOLAR_URL, params=params, timeout=30)
+
+                if response.status_code != 200:
+                    logger.error(f"Search failed with status {response.status_code}")
+                    break
+
+                # Parse results
+                soup = BeautifulSoup(response.text, "html.parser")
+                results = soup.find_all("div", class_="gs_ri")
+
+                if not results:
+                    logger.info("No more results found")
+                    break
+
+                # Process each result
+                for item in results:
+                    if len(papers) >= max_results:
+                        break
+
+                    paper = self._parse_paper(item)
+                    if paper:
+                        papers.append(paper)
+
+                start += results_per_page
+
+            except requests.exceptions.RequestException as e:
+                logger.error(f"Network error during search: {e}")
+                break
+            except Exception as e:
+                logger.error(f"Search error: {e}")
+                break
+
+        return papers[:max_results]
+
+    def download_pdf(self, paper_id: str, save_path: str) -> str:
+        """
+        Google Scholar doesn't support direct PDF downloads
+
+        Args:
+            paper_id: Paper identifier
+            save_path: Directory to save the PDF
+
+        Returns:
+            Error message explaining limitation
+
+        Raises:
+            NotImplementedError: Always raises this error
+        """
+        raise NotImplementedError(
+            "Google Scholar doesn't provide direct PDF downloads. "
+            "Please use the paper URL to access the publisher's website."
+        )
+
+    def read_paper(self, paper_id: str, save_path: str = "./downloads") -> str:
+        """
+        Google Scholar doesn't support direct paper reading
+
+        Args:
+            paper_id: Paper identifier
+            save_path: Directory where papers are stored
+
+        Returns:
+            Message indicating the feature is not supported
+        """
+        return (
+            "Google Scholar doesn't support direct paper reading. "
+            "Please use the paper URL to access the full text on the publisher's website."
+        )

all_in_mcp/paper.py

@@ -1,6 +1,12 @@
 # all_in_mcp/paper.py
+import io
 from dataclasses import dataclass
 from datetime import datetime
+from pathlib import Path
+from urllib.parse import urlparse
+
+import httpx
+from pypdf import PdfReader
 
 
 @dataclass
@@ -62,3 +68,134 @@ class Paper:
             "references": self.references,
             "extra": self.extra,
         }
+
+    def read_content(self) -> str:
+        """
+        Read the full text content of this paper's PDF.
+
+        Returns:
+            str: Extracted text content from the paper's PDF
+
+        Raises:
+            ValueError: If no PDF URL is available
+            Exception: If PDF cannot be read or processed
+        """
+        if not self.pdf_url:
+            raise ValueError("No PDF URL available for this paper")
+
+        return read_pdf(self.pdf_url)
+
+
+def read_pdf(pdf_source: str | Path) -> str:
+    """
+    Extract text content from a PDF file (local or online).
+
+    Args:
+        pdf_source: Path to local PDF file or URL to online PDF
+
+    Returns:
+        str: Extracted text content from the PDF
+
+    Raises:
+        FileNotFoundError: If local file doesn't exist
+        ValueError: If URL is invalid or PDF cannot be processed
+        Exception: For other PDF processing errors
+    """
+    try:
+        if isinstance(pdf_source, str | Path):
+            pdf_source_str = str(pdf_source)
+
+            # Check if it's a URL
+            parsed = urlparse(pdf_source_str)
+            if parsed.scheme in ("http", "https"):
+                # Handle online PDF
+                return _read_pdf_from_url(pdf_source_str)
+            else:
+                # Handle local file
+                return _read_pdf_from_file(Path(pdf_source_str))
+        else:
+            raise ValueError("pdf_source must be a string or Path object")
+
+    except Exception as e:
+        raise Exception(f"Failed to read PDF from {pdf_source}: {e!s}") from e
+
+
+def _read_pdf_from_file(file_path: Path) -> str:
+    """Read PDF from local file path."""
+    if not file_path.exists():
+        raise FileNotFoundError(f"PDF file not found: {file_path}")
+
+    if not file_path.suffix.lower() == ".pdf":
+        raise ValueError(f"File must have .pdf extension: {file_path}")
+
+    try:
+        with open(file_path, "rb") as file:
+            pdf_reader = PdfReader(file)
+            text_content = []
+
+            for page_num, page in enumerate(pdf_reader.pages):
+                try:
+                    page_text = page.extract_text()
+                    if page_text.strip():  # Only add non-empty pages
+                        text_content.append(
+                            f"--- Page {page_num + 1} ---\n{page_text}\n"
+                        )
+                except Exception as e:
+                    text_content.append(
+                        f"--- Page {page_num + 1} (Error reading page: {e!s}) ---\n"
+                    )
+
+            return "\n".join(text_content)
+
+    except Exception as e:
+        raise Exception(f"Error reading PDF file {file_path}: {e!s}") from e
+
+
+def _read_pdf_from_url(url: str) -> str:
+    """Download and read PDF from URL."""
+    try:
+        # Download PDF with proper headers
+        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"
+        }
+
+        with httpx.Client(timeout=30.0, headers=headers) as client:
+            response = client.get(url)
+            response.raise_for_status()
+
+            # Check if content is actually a PDF
+            content_type = response.headers.get("content-type", "").lower()
+            if "application/pdf" not in content_type and not url.lower().endswith(
+                ".pdf"
+            ):
+                # Try to detect PDF by content
+                if not response.content.startswith(b"%PDF"):
+                    raise ValueError(f"URL does not point to a valid PDF file: {url}")
+
+            # Read PDF from bytes
+            pdf_bytes = io.BytesIO(response.content)
+            pdf_reader = PdfReader(pdf_bytes)
+            text_content = []
+
+            for page_num, page in enumerate(pdf_reader.pages):
+                try:
+                    page_text = page.extract_text()
+                    if page_text.strip():  # Only add non-empty pages
+                        text_content.append(
+                            f"--- Page {page_num + 1} ---\n{page_text}\n"
+                        )
+                except Exception as e:
+                    text_content.append(
+                        f"--- Page {page_num + 1} (Error reading page: {e!s}) ---\n"
+                    )
+
+            return "\n".join(text_content)
+
+    except httpx.RequestError as e:
+        raise Exception(f"Network error downloading PDF from {url}: {e!s}") from e
+    except httpx.HTTPStatusError as e:
+        raise Exception(
+            f"HTTP error {e.response.status_code} downloading PDF from {url}"
+        ) from e
+    except Exception as e:
+        raise Exception(f"Error processing PDF from URL {url}: {e!s}") from e

all_in_mcp/server.py

@@ -1,19 +1,23 @@
-import os
-from typing import List, Dict
 import mcp.server.stdio
 import mcp.types as types
 from mcp.server import NotificationOptions, Server
 from mcp.server.models import InitializationOptions
 
+from .academic_platforms.cryptobib import CryptoBibSearcher
+from .academic_platforms.crossref import CrossrefSearcher
+from .academic_platforms.google_scholar import GoogleScholarSearcher
+
 # Import searchers
 from .academic_platforms.iacr import IACRSearcher
-from .academic_platforms.cryptobib import CryptoBibSearcher
+from .paper import read_pdf
 
 server = Server("all-in-mcp")
 
 # Initialize searchers
 iacr_searcher = IACRSearcher()
 cryptobib_searcher = CryptoBibSearcher(cache_dir="./downloads")
+crossref_searcher = CrossrefSearcher()
+google_scholar_searcher = GoogleScholarSearcher()
 
 
 @server.list_tools()
@@ -122,6 +126,117 @@ async def handle_list_tools() -> list[types.Tool]:
                 "required": ["query"],
             },
         ),
+        types.Tool(
+            name="search-google-scholar-papers",
+            description="Search academic papers from Google Scholar",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query string (e.g., 'machine learning', 'neural networks')",
+                    },
+                    "max_results": {
+                        "type": "integer",
+                        "description": "Maximum number of papers to return (default: 10)",
+                        "default": 10,
+                    },
+                    "year_low": {
+                        "type": "integer",
+                        "description": "Minimum publication year (optional)",
+                    },
+                    "year_high": {
+                        "type": "integer",
+                        "description": "Maximum publication year (optional)",
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        types.Tool(
+            name="search-crossref-papers",
+            description="Search academic papers from Crossref database",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query string (e.g., 'quantum computing', 'machine learning')",
+                    },
+                    "max_results": {
+                        "type": "integer",
+                        "description": "Maximum number of papers to return (default: 10)",
+                        "default": 10,
+                    },
+                    "year_min": {
+                        "type": "integer",
+                        "description": "Minimum publication year (optional)",
+                    },
+                    "year_max": {
+                        "type": "integer",
+                        "description": "Maximum publication year (optional)",
+                    },
+                    "sort_by": {
+                        "type": "string",
+                        "description": "Sort order: relevance, published, indexed, updated (default: relevance)",
+                        "default": "relevance",
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        types.Tool(
+            name="download-crossref-paper",
+            description="Download PDF of a Crossref paper (when available from publisher)",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "paper_id": {
+                        "type": "string",
+                        "description": "DOI or URL of the paper",
+                    },
+                    "save_path": {
+                        "type": "string",
+                        "description": "Directory to save the PDF (default: './downloads')",
+                        "default": "./downloads",
+                    },
+                },
+                "required": ["paper_id"],
+            },
+        ),
+        types.Tool(
+            name="read-crossref-paper",
+            description="Read and extract text content from a Crossref paper PDF",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "paper_id": {
+                        "type": "string",
+                        "description": "DOI or URL of the paper",
+                    },
+                    "save_path": {
+                        "type": "string",
+                        "description": "Directory where the PDF is/will be saved (default: './downloads')",
+                        "default": "./downloads",
+                    },
+                },
+                "required": ["paper_id"],
+            },
+        ),
+        types.Tool(
+            name="read-pdf",
+            description="Read and extract text content from a PDF file (local or online)",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "pdf_source": {
+                        "type": "string",
+                        "description": "Path to local PDF file or URL to online PDF",
+                    },
+                },
+                "required": ["pdf_source"],
+            },
+        ),
     ]
 
 
@@ -323,6 +438,223 @@ async def handle_call_tool(
 
                 return [types.TextContent(type="text", text=result_text)]
 
+        elif name == "search-google-scholar-papers":
+            query = arguments.get("query", "")
+            max_results = arguments.get("max_results", 10)
+            year_low = arguments.get("year_low")
+            year_high = arguments.get("year_high")
+
+            if not query:
+                return [
+                    types.TextContent(
+                        type="text", text="Error: Query parameter is required"
+                    )
+                ]
+
+            try:
+                papers = google_scholar_searcher.search(
+                    query,
+                    max_results=max_results,
+                    year_low=year_low,
+                    year_high=year_high,
+                )
+
+                if not papers:
+                    year_filter_msg = ""
+                    if year_low or year_high:
+                        year_range = (
+                            f" ({year_low or 'earliest'}-{year_high or 'latest'})"
+                        )
+                        year_filter_msg = f" in year range{year_range}"
+                    return [
+                        types.TextContent(
+                            type="text",
+                            text=f"No papers found for query: {query}{year_filter_msg}",
+                        )
+                    ]
+
+                year_filter_msg = ""
+                if year_low or year_high:
+                    year_range = f" ({year_low or 'earliest'}-{year_high or 'latest'})"
+                    year_filter_msg = f" in year range{year_range}"
+
+                result_text = f"Found {len(papers)} Google Scholar papers for query '{query}'{year_filter_msg}:\n\n"
+                for i, paper in enumerate(papers, 1):
+                    result_text += f"{i}. **{paper.title}**\n"
+                    result_text += f"   - Authors: {', '.join(paper.authors)}\n"
+                    if paper.citations > 0:
+                        result_text += f"   - Citations: {paper.citations}\n"
+                    if paper.published_date and paper.published_date.year > 1900:
+                        result_text += f"   - Year: {paper.published_date.year}\n"
+                    if paper.url:
+                        result_text += f"   - URL: {paper.url}\n"
+                    if paper.abstract:
+                        # Truncate abstract for readability
+                        abstract_preview = (
+                            paper.abstract[:300] + "..."
+                            if len(paper.abstract) > 300
+                            else paper.abstract
+                        )
+                        result_text += f"   - Abstract: {abstract_preview}\n"
+                    result_text += "\n"
+
+                return [types.TextContent(type="text", text=result_text)]
+
+            except Exception as e:
+                return [
+                    types.TextContent(
+                        type="text", text=f"Error searching Google Scholar: {e!s}"
+                    )
+                ]
+
+        elif name == "search-crossref-papers":
+            query = arguments.get("query", "")
+            max_results = arguments.get("max_results", 10)
+            year_min = arguments.get("year_min")
+            year_max = arguments.get("year_max")
+            sort_by = arguments.get("sort_by", "relevance")
+
+            if not query:
+                return [
+                    types.TextContent(
+                        type="text", text="Error: Query parameter is required"
+                    )
+                ]
+
+            try:
+                papers = crossref_searcher.search(
+                    query,
+                    max_results=max_results,
+                    year_min=year_min,
+                    year_max=year_max,
+                    sort_by=sort_by,
+                )
+
+                if not papers:
+                    year_filter_msg = ""
+                    if year_min or year_max:
+                        year_range = (
+                            f" ({year_min or 'earliest'}-{year_max or 'latest'})"
+                        )
+                        year_filter_msg = f" in year range{year_range}"
+                    return [
+                        types.TextContent(
+                            type="text",
+                            text=f"No papers found for query: {query}{year_filter_msg}",
+                        )
+                    ]
+
+                year_filter_msg = ""
+                if year_min or year_max:
+                    year_range = f" ({year_min or 'earliest'}-{year_max or 'latest'})"
+                    year_filter_msg = f" in year range{year_range}"
+
+                result_text = f"Found {len(papers)} Crossref papers for query '{query}'{year_filter_msg}:\n\n"
+                for i, paper in enumerate(papers, 1):
+                    result_text += f"{i}. **{paper.title}**\n"
+                    result_text += f"   - Authors: {', '.join(paper.authors)}\n"
+                    if paper.doi:
+                        result_text += f"   - DOI: {paper.doi}\n"
+                    if paper.citations > 0:
+                        result_text += f"   - Citations: {paper.citations}\n"
+                    if paper.published_date and paper.published_date.year > 1900:
+                        result_text += f"   - Year: {paper.published_date.year}\n"
+                    if paper.extra and paper.extra.get("journal"):
+                        result_text += f"   - Journal: {paper.extra['journal']}\n"
+                    if paper.extra and paper.extra.get("volume"):
+                        result_text += f"   - Volume: {paper.extra['volume']}\n"
+                    if paper.extra and paper.extra.get("pages"):
+                        result_text += f"   - Pages: {paper.extra['pages']}\n"
+                    if paper.url:
+                        result_text += f"   - URL: {paper.url}\n"
+                    if paper.abstract:
+                        # Truncate abstract for readability
+                        abstract_preview = (
+                            paper.abstract[:300] + "..."
+                            if len(paper.abstract) > 300
+                            else paper.abstract
+                        )
+                        result_text += f"   - Abstract: {abstract_preview}\n"
+                    result_text += "\n"
+
+                return [types.TextContent(type="text", text=result_text)]
+
+            except Exception as e:
+                return [
+                    types.TextContent(
+                        type="text", text=f"Error searching Crossref: {e!s}"
+                    )
+                ]
+
+        elif name == "download-crossref-paper":
+            paper_id = arguments.get("paper_id", "")
+            save_path = arguments.get("save_path", "./downloads")
+
+            if not paper_id:
+                return [
+                    types.TextContent(
+                        type="text", text="Error: paper_id parameter is required"
+                    )
+                ]
+
+            result = crossref_searcher.download_pdf(paper_id, save_path)
+
+            if result.startswith("Error"):
+                return [types.TextContent(type="text", text=result)]
+            else:
+                return [
+                    types.TextContent(
+                        type="text", text=f"PDF downloaded successfully to: {result}"
+                    )
+                ]
+
+        elif name == "read-crossref-paper":
+            paper_id = arguments.get("paper_id", "")
+            save_path = arguments.get("save_path", "./downloads")
+
+            if not paper_id:
+                return [
+                    types.TextContent(
+                        type="text", text="Error: paper_id parameter is required"
+                    )
+                ]
+
+            result = crossref_searcher.read_paper(paper_id, save_path)
+
+            if result.startswith("Error"):
+                return [types.TextContent(type="text", text=result)]
+            else:
+                # Truncate very long text for display
+                if len(result) > 5000:
+                    truncated_result = (
+                        result[:5000]
+                        + f"\n\n... [Text truncated. Full text is {len(result)} characters long]"
+                    )
+                    return [types.TextContent(type="text", text=truncated_result)]
+                else:
+                    return [types.TextContent(type="text", text=result)]
+
+        elif name == "read-pdf":
+            pdf_source = arguments.get("pdf_source", "")
+
+            if not pdf_source:
+                return [
+                    types.TextContent(
+                        type="text", text="Error: pdf_source parameter is required"
+                    )
+                ]
+
+            try:
+                result = read_pdf(pdf_source)
+                return [types.TextContent(type="text", text=result)]
+
+            except Exception as e:
+                return [
+                    types.TextContent(
+                        type="text", text=f"Error reading PDF from {pdf_source}: {e!s}"
+                    )
+                ]
+
         else:
             raise ValueError(f"Unknown tool: {name}")
 

{all_in_mcp-0.2.2.dist-info → all_in_mcp-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: all-in-mcp
-Version: 0.2.2
+Version: 0.2.5
 Summary: An MCP (Model Context Protocol) server providing daily-use utility functions and academic paper search capabilities
 Project-URL: Homepage, https://github.com/jiahaoxiang2000/all-in-mcp
 Project-URL: Repository, https://github.com/jiahaoxiang2000/all-in-mcp
@@ -53,6 +53,8 @@ An MCP (Model Context Protocol) server that provides daily-use utility functions
 
 - **Academic Research**: IACR ePrint Archive paper search, download, and reading
 - **Bibliography Search**: CryptoBib database search for cryptography papers
+- **Google Scholar**: Search academic papers across disciplines with citation data
+- **PDF Reading**: Read and extract text from local and online PDF files
 
 ### Paper Search Capabilities
 
@@ -70,6 +72,13 @@ An MCP (Model Context Protocol) server that provides daily-use utility functions
 - Retrieve structured paper metadata or raw BibTeX entries
 - Support for all major cryptography venues and conferences
 
+#### Google Scholar
+
+- Search academic papers across multiple disciplines
+- Access to citation counts and publication metadata
+- Broad coverage of academic literature from various sources
+- Year-based filtering for targeted searches
+
 ## Quick Start
 
 ### Prerequisites

all_in_mcp-0.2.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+all_in_mcp/__init__.py,sha256=REDwcbifpuUnsFAhNowIKCZ-8g6irIzUFTI_f8Aunxk,215
+all_in_mcp/paper.py,sha256=vSJyC_ehfZX5-ASYG048z8gaD1LKafFdJvR13iQcJRw,7104
+all_in_mcp/server.py,sha256=DyfOtcVclzh6qgN42lETH_3cUXe2qrBXdCFUfDfQvH0,27740
+all_in_mcp/academic_platforms/__init__.py,sha256=IpI29DMS4_mSmTEa8VkQEiJCl7OyFbswSx7mWSp08P4,285
+all_in_mcp/academic_platforms/base.py,sha256=VYMp8_tnp7YzXKAXLfr7uUxgvJBNKRyC_NT1uVhBOwY,673
+all_in_mcp/academic_platforms/crossref.py,sha256=Lun9-D_MgS9kFlQquktg6NXsG1S6nU24s87Y_sOJc0s,10983
+all_in_mcp/academic_platforms/cryptobib.py,sha256=F9N23eojfyAIjnFDPrJAYOpZ_Vi9iHOqNHGtKC6O16c,17360
+all_in_mcp/academic_platforms/google_scholar.py,sha256=_KLFfIOZeFCGxFOt-nwzm1fgZKMlXOf3HvIjXAYE5cI,8737
+all_in_mcp/academic_platforms/iacr.py,sha256=MUPxFycVS0eMsJok71y12RUqjxbRrCReG33V5ORAbfU,15450
+all_in_mcp-0.2.5.dist-info/METADATA,sha256=PKH2VSeQJzZ7HiVKoh4zmkQntOsOuSDmsM6u0b8eifg,6067
+all_in_mcp-0.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+all_in_mcp-0.2.5.dist-info/entry_points.txt,sha256=FbQOtUQzOIfkMNp4qQV1NTU9K4J7C0XGH9wKKhfK1VM,47
+all_in_mcp-0.2.5.dist-info/licenses/LICENSE,sha256=idExTHItK7AC5FVo4H9HKnr6h51Z8BKCEztZPyP8nK8,1062
+all_in_mcp-0.2.5.dist-info/RECORD,,

all_in_mcp-0.2.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-all_in_mcp/__init__.py,sha256=REDwcbifpuUnsFAhNowIKCZ-8g6irIzUFTI_f8Aunxk,215
-all_in_mcp/paper.py,sha256=QVH2BQpQT3I14T2IaZs1ZeC-MJVoFNVYZXSs1iHlGLY,2293
-all_in_mcp/server.py,sha256=CDiHXXMPlNPMLcpnjrZ5zoKrujNxZLryf8ecgtYt-bg,13971
-all_in_mcp/academic_platforms/__init__.py,sha256=-Asc2WpmfyvCCF0s-Ni6kcz8dkyyV7n3gjhhD2Oq1BA,210
-all_in_mcp/academic_platforms/base.py,sha256=VYMp8_tnp7YzXKAXLfr7uUxgvJBNKRyC_NT1uVhBOwY,673
-all_in_mcp/academic_platforms/cryptobib.py,sha256=4vLVNQdWBw6YLHPlw6bJVEGlsoihPE9rUfNCiAdu5Ic,17399
-all_in_mcp/academic_platforms/iacr.py,sha256=MUPxFycVS0eMsJok71y12RUqjxbRrCReG33V5ORAbfU,15450
-all_in_mcp-0.2.2.dist-info/METADATA,sha256=tHh2ZAZkW_mRnk44Arz06bn0xxyMV4xoAtJKuf7_rXs,5677
-all_in_mcp-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-all_in_mcp-0.2.2.dist-info/entry_points.txt,sha256=FbQOtUQzOIfkMNp4qQV1NTU9K4J7C0XGH9wKKhfK1VM,47
-all_in_mcp-0.2.2.dist-info/licenses/LICENSE,sha256=idExTHItK7AC5FVo4H9HKnr6h51Z8BKCEztZPyP8nK8,1062
-all_in_mcp-0.2.2.dist-info/RECORD,,