all-in-mcp 0.2.3__py3-none-any.whl → 0.2.6__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__ = ["CryptoBibSearcher", "IACRSearcher", "PaperSource"]
+__all__ = ["CryptoBibSearcher", "GoogleScholarSearcher", "IACRSearcher", "PaperSource"]

all_in_mcp/academic_platforms/crossref.py

@@ -0,0 +1,256 @@
+# 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:
+        """
+        Not implemented: Download PDF for a paper (limited functionality for Crossref)
+        """
+        return "Crossref does not provide a direct way to download PDFs. Use the paper's URL or DOI to access the publisher's site for PDF downloads if available."
+
+    def read_paper(self, paper_id: str, save_path: str) -> str:
+        """
+        crossref doesn't provide a direct way to read paper text.
+        """
+        return "Crossref does not provide a direct way to read paper text. Use the download_pdf method to get the PDF if available."
+
+    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/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/server.py

@@ -4,6 +4,8 @@ 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
@@ -14,6 +16,8 @@ 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,65 @@ 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="read-pdf",
             description="Read and extract text content from a PDF file (local or online)",
@@ -337,6 +400,154 @@ 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 == "read-pdf":
             pdf_source = arguments.get("pdf_source", "")
 

all_in_mcp-0.2.6.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: all-in-mcp
+Version: 0.2.6
+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
+Project-URL: Documentation, https://github.com/jiahaoxiang2000/all-in-mcp/tree/main/docs
+Project-URL: Issues, https://github.com/jiahaoxiang2000/all-in-mcp/issues
+Author-email: isomo <jiahaoxiang2000@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: academic,iacr,mcp,model-context-protocol,papers,utilities
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: General
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: feedparser>=6.0.10
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: mcp>=1.9.4
+Requires-Dist: pypdf>=4.0.0
+Requires-Dist: requests>=2.31.0
+Provides-Extra: all
+Requires-Dist: psutil>=5.9.0; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: build>=1.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.5.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Requires-Dist: twine>=4.0.0; extra == 'dev'
+Provides-Extra: system
+Requires-Dist: psutil>=5.9.0; extra == 'system'
+Description-Content-Type: text/markdown
+
+# All-in-MCP
+
+An MCP (Model Context Protocol) server that provides utility functions, including academic paper search capabilities.
+
+- [**Paper Tools overview _Video_**](https://www.bilibili.com/video/BV1RMKWzdEk8)
+- [_Overview PDF_](https://github.com/jiahaoxiang2000/tutor/blob/main/Apaper/setup.pdf)
+
+## Features
+
+This MCP server exposes the following daily-use utility tools as MCP endpoints:
+
+### Available Tools
+
+- **Academic Research**:
+  - `search-iacr-papers`: Search academic papers from IACR ePrint Archive
+  - `download-iacr-paper`: Download PDF of an IACR ePrint paper
+  - `read-iacr-paper`: Read and extract text content from an IACR ePrint paper PDF
+- **Bibliography Search**:
+  - `search-cryptobib-papers`: Search CryptoBib bibliography database for cryptography papers (structured metadata or raw BibTeX)
+- **Crossref Search**:
+  - `search-crossref-papers`: Search academic papers from Crossref database
+- **Google Scholar**:
+  - `search-google-scholar-papers`: Search academic papers across disciplines with citation data
+- **PDF Reading**:
+  - `read-pdf`: Read and extract text from local and online PDF files
+
+All tools are implemented as async MCP endpoints with proper validation and error handling.
+
+## Quick Start
+
+- [**Video for Env Setup**](https://www.bilibili.com/video/BV1cZKozaEjg)
+- [_Overview PDF_](https://github.com/jiahaoxiang2000/tutor/blob/main/Apaper/config.pdf)
+
+### Prerequisites
+
+- Python 3.12 or higher
+- UV package manager
+
+### Installation
+
+Install from PyPI (Recommended by `UV`)
+
+```bash
+uv pip install all-in-mcp
+```
+
+### Integration with MCP Clients Vscode
+
+Add this server to your MCP client configuration. The server runs using stdio transport.
+
+Example configuration for Vscode:
+
+```json .vscode/mcp.json
+{
+  "servers": {
+    "all-in-mcp": {
+      "type": "stdio",
+      "command": "uv",
+      "args": ["run", "all-in-mcp"]
+    }
+  }
+}
+```
+
+<details>
+<summary>Development</summary>
+
+For development setup and contribution guidelines, see the [Development Guide](docs/development.md).
+
+### Quick Development Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/jiahaoxiang2000/all-in-mcp.git
+cd all-in-mcp
+
+# Install with development dependencies
+uv sync --extra dev
+
+# Run tests
+uv run pytest
+```
+
+</details>

all_in_mcp-0.2.6.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=GAb_RUlFi2UyXOASB9IM_fQmHHr5F6bQXbPV8J964pI,24420
+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=D-wvSwnOocP16m9fA3xJ6VGEpmRPtMmGoFm5MlyPdXE,8707
+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.6.dist-info/METADATA,sha256=viUPVp5EJXz5XdzgI-ZewGAWZBok5eu2LvSH5QYMjRQ,4242
+all_in_mcp-0.2.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+all_in_mcp-0.2.6.dist-info/entry_points.txt,sha256=FbQOtUQzOIfkMNp4qQV1NTU9K4J7C0XGH9wKKhfK1VM,47
+all_in_mcp-0.2.6.dist-info/licenses/LICENSE,sha256=idExTHItK7AC5FVo4H9HKnr6h51Z8BKCEztZPyP8nK8,1062
+all_in_mcp-0.2.6.dist-info/RECORD,,

all_in_mcp-0.2.3.dist-info/METADATA

@@ -1,218 +0,0 @@
-Metadata-Version: 2.4
-Name: all-in-mcp
-Version: 0.2.3
-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
-Project-URL: Documentation, https://github.com/jiahaoxiang2000/all-in-mcp/tree/main/docs
-Project-URL: Issues, https://github.com/jiahaoxiang2000/all-in-mcp/issues
-Author-email: isomo <jiahaoxiang2000@gmail.com>
-License: MIT
-License-File: LICENSE
-Keywords: academic,iacr,mcp,model-context-protocol,papers,utilities
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Scientific/Engineering
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Text Processing :: General
-Requires-Python: >=3.10
-Requires-Dist: beautifulsoup4>=4.12.0
-Requires-Dist: feedparser>=6.0.10
-Requires-Dist: httpx>=0.24.0
-Requires-Dist: mcp>=1.9.4
-Requires-Dist: pypdf>=4.0.0
-Requires-Dist: requests>=2.31.0
-Provides-Extra: all
-Requires-Dist: psutil>=5.9.0; extra == 'all'
-Provides-Extra: dev
-Requires-Dist: build>=1.0.0; extra == 'dev'
-Requires-Dist: mypy>=1.5.0; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
-Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
-Requires-Dist: pytest>=8.0.0; extra == 'dev'
-Requires-Dist: ruff>=0.1.0; extra == 'dev'
-Requires-Dist: twine>=4.0.0; extra == 'dev'
-Provides-Extra: system
-Requires-Dist: psutil>=5.9.0; extra == 'system'
-Description-Content-Type: text/markdown
-
-# All-in-MCP
-
-An MCP (Model Context Protocol) server that provides daily-use utility functions, including academic paper search capabilities.
-
-## Features
-
-### Daily Utilities
-
-- **Academic Research**: IACR ePrint Archive paper search, download, and reading
-- **Bibliography Search**: CryptoBib database search for cryptography papers
-- **PDF Reading**: Read and extract text from local and online PDF files
-
-### Paper Search Capabilities
-
-#### IACR ePrint Archive
-
-- Search academic papers from IACR ePrint Archive
-- Download PDF files
-- Extract and read text content from papers
-- Metadata extraction (authors, publication dates, abstracts)
-
-#### CryptoBib Database
-
-- Search comprehensive cryptography bibliography database
-- Access to thousands of cryptographic research papers
-- Retrieve structured paper metadata or raw BibTeX entries
-- Support for all major cryptography venues and conferences
-
-## Quick Start
-
-### Prerequisites
-
-- Python 3.12 or higher
-- UV package manager
-
-## Installation
-
-### Option 1: Install from PyPI (Recommended)
-
-```bash
-pip install all-in-mcp
-```
-
-### Option 2: Install from Source
-
-1. Clone this repository:
-
-   ```bash
-   git clone https://github.com/jiahaoxiang2000/all-in-mcp.git
-   cd all-in-mcp
-   ```
-
-2. Install with UV:
-
-   ```bash
-   uv sync
-   ```
-
-### Running the Server
-
-After installation, you can run the MCP server directly:
-
-```bash
-all-in-mcp
-```
-
-Or if you installed from source with UV:
-
-```bash
-uv run all-in-mcp
-```
-
-## Integration with MCP Clients
-
-Add this server to your MCP client configuration. The server runs using stdio transport.
-See detailed integration guide in [`docs/INTEGRATION.md`](docs/INTEGRATION.md).
-
-Example configuration for Claude Desktop:
-
-```json
-{
-  "mcpServers": {
-    "all-in-mcp": {
-      "command": "uv",
-      "args": ["run", "all-in-mcp"],
-      "cwd": "/path/to/all-in-mcp"
-    }
-  }
-}
-```
-
-## Development
-
-For development setup and contribution guidelines, see the [Development Guide](docs/development.md).
-
-### Quick Development Setup
-
-```bash
-# Clone the repository
-git clone https://github.com/jiahaoxiang2000/all-in-mcp.git
-cd all-in-mcp
-
-# Install with development dependencies
-uv sync --extra dev
-
-# Run tests
-uv run pytest
-
-# Run linting
-uv run ruff check src/
-uv run ruff format src/
-
-# Type checking
-uv run mypy src/all_in_mcp
-```
-
-### Releases
-
-This project uses the existing release helper script for creating releases:
-
-#### Using the Release Script
-
-Use the release helper script to create a new version:
-
-```bash
-python scripts/release.py 0.1.2
-```
-
-This script will:
-
-1. Update the version in `pyproject.toml`
-2. Create a git commit
-3. Create a git tag
-4. Push the changes to trigger CI/CD
-
-#### Manual Process
-
-Alternatively, you can manually:
-
-1. **Update version** in `pyproject.toml`:
-
-   ```toml
-   version = "0.1.2"  # Change this
-   ```
-
-2. **Commit and tag**:
-
-   ```bash
-   git add pyproject.toml
-   git commit -m "Bump version to 0.1.2"
-   git tag v0.1.2
-   git push --follow-tags
-   ```
-
-### Debugging
-
-For debugging, use the [MCP Inspector](https://github.com/modelcontextprotocol/inspector):
-
-```bash
-npx @modelcontextprotocol/inspector uv --directory /path/to/all-in-mcp run all-in-mcp
-```
-
-## Documentation
-
-Complete documentation is available in the [`docs/`](docs/) directory:
-
-- **[API Reference](docs/api.md)** - Complete API documentation
-- **[Installation Guide](docs/installation.md)** - Setup instructions
-- **[IACR Integration](docs/iacr.md)** - Academic paper search details
-- **[CryptoBib Integration](docs/cryptobib.md)** - Bibliography database search
-- **[Development Guide](docs/development.md)** - Contributing guidelines
-- **[PyPI Setup Guide](docs/pypi-setup.md)** - Publishing configuration
-- **[Examples](docs/examples.md)** - Usage examples

all_in_mcp-0.2.3.dist-info/RECORD

@@ -1,12 +0,0 @@
-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=pMGyRbgr_kwC_ZNsxMUwXcoEQ8fW4NZx3Sns7uRRa8I,15140
-all_in_mcp/academic_platforms/__init__.py,sha256=2KgWMc38NBhRkiLYwqyKi43u-Wm5vWK8i-es3fQFlN0,210
-all_in_mcp/academic_platforms/base.py,sha256=VYMp8_tnp7YzXKAXLfr7uUxgvJBNKRyC_NT1uVhBOwY,673
-all_in_mcp/academic_platforms/cryptobib.py,sha256=F9N23eojfyAIjnFDPrJAYOpZ_Vi9iHOqNHGtKC6O16c,17360
-all_in_mcp/academic_platforms/iacr.py,sha256=MUPxFycVS0eMsJok71y12RUqjxbRrCReG33V5ORAbfU,15450
-all_in_mcp-0.2.3.dist-info/METADATA,sha256=43FE07lBZ-f92fi1AemtCEQO_IVXyKD1d_keztjtcYI,5750
-all_in_mcp-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-all_in_mcp-0.2.3.dist-info/entry_points.txt,sha256=FbQOtUQzOIfkMNp4qQV1NTU9K4J7C0XGH9wKKhfK1VM,47
-all_in_mcp-0.2.3.dist-info/licenses/LICENSE,sha256=idExTHItK7AC5FVo4H9HKnr6h51Z8BKCEztZPyP8nK8,1062
-all_in_mcp-0.2.3.dist-info/RECORD,,