all-in-mcp 0.1.4__py3-none-any.whl

all_in_mcp/__init__.py

@@ -0,0 +1,11 @@
+import asyncio
+
+from . import server
+
+
+def main():
+    """Main entry point for the package."""
+    asyncio.run(server.main())
+
+# Optionally expose other important items at package level
+__all__ = ['main', 'server']

all_in_mcp/academic_platforms/__init__.py

@@ -0,0 +1 @@
+# all_in_mcp/academic_platforms/__init__.py

all_in_mcp/academic_platforms/base.py

@@ -0,0 +1,23 @@
+# all_in_mcp/academic_platforms/base.py
+from abc import ABC, abstractmethod
+
+from ..paper import Paper
+
+
+class PaperSource(ABC):
+    """Abstract base class for paper sources"""
+
+    @abstractmethod
+    def search(self, query: str, **kwargs) -> list[Paper]:
+        """Search for papers based on query"""
+        raise NotImplementedError
+
+    @abstractmethod
+    def download_pdf(self, paper_id: str, save_path: str) -> str:
+        """Download PDF of a paper"""
+        raise NotImplementedError
+
+    @abstractmethod
+    def read_paper(self, paper_id: str, save_path: str) -> str:
+        """Read and extract text content from a paper"""
+        raise NotImplementedError

all_in_mcp/academic_platforms/iacr.py

@@ -0,0 +1,427 @@
+# all_in_mcp/academic_platforms/iacr.py
+import logging
+import os
+import random
+from datetime import datetime
+from typing import ClassVar
+
+import requests
+from bs4 import BeautifulSoup
+from pypdf import PdfReader
+
+from ..paper import Paper
+from .base import PaperSource
+
+logger = logging.getLogger(__name__)
+
+
+class IACRSearcher(PaperSource):
+    """IACR ePrint Archive paper search implementation"""
+
+    IACR_SEARCH_URL = "https://eprint.iacr.org/search"
+    IACR_BASE_URL = "https://eprint.iacr.org"
+    BROWSERS: ClassVar[list[str]] = [
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36",
+    ]
+
+    def __init__(self):
+        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",
+                "Accept-Language": "en-US,en;q=0.9",
+            }
+        )
+
+    def _parse_date(self, date_str: str) -> datetime | None:
+        """Parse date from IACR format (e.g., '2025-06-02')"""
+        try:
+            return datetime.strptime(date_str.strip(), "%Y-%m-%d")
+        except ValueError:
+            logger.warning(f"Could not parse date: {date_str}")
+            return None
+
+    def _parse_paper(self, item, fetch_details: bool = True) -> Paper | None:
+        """Parse single paper entry from IACR HTML and optionally fetch detailed info"""
+        try:
+            # Extract paper ID from the search result
+            header_div = item.find("div", class_="d-flex")
+            if not header_div:
+                return None
+
+            # Get paper ID from the link
+            paper_link = header_div.find("a", class_="paperlink")
+            if not paper_link:
+                return None
+
+            paper_id = paper_link.get_text(strip=True)  # e.g., "2025/1014"
+
+            if fetch_details:
+                # Fetch detailed information for this paper
+                logger.info(f"Fetching detailed info for paper {paper_id}")
+                detailed_paper = self.get_paper_details(paper_id)
+                if detailed_paper:
+                    return detailed_paper
+                else:
+                    logger.warning(
+                        f"Could not fetch details for {paper_id}, falling back to search result parsing"
+                    )
+
+            # Fallback: parse from search results if detailed fetch fails or is disabled
+            paper_url = self.IACR_BASE_URL + paper_link["href"]
+
+            # Get PDF URL
+            pdf_link = header_div.find("a", href=True, string="(PDF)")
+            pdf_url = self.IACR_BASE_URL + pdf_link["href"] if pdf_link else ""
+
+            # Get last updated date
+            last_updated_elem = header_div.find("small", class_="ms-auto")
+            updated_date = None
+            if last_updated_elem:
+                date_text = last_updated_elem.get_text(strip=True)
+                if "Last updated:" in date_text:
+                    date_str = date_text.replace("Last updated:", "").strip()
+                    updated_date = self._parse_date(date_str)
+
+            # Get content from the second div
+            content_div = item.find("div", class_="ms-md-4")
+            if not content_div:
+                return None
+
+            # Extract title
+            title_elem = content_div.find("strong")
+            title = title_elem.get_text(strip=True) if title_elem else ""
+
+            # Extract authors
+            authors_elem = content_div.find("span", class_="fst-italic")
+            authors = []
+            if authors_elem:
+                authors_text = authors_elem.get_text(strip=True)
+                authors = [author.strip() for author in authors_text.split(",")]
+
+            # Extract category
+            category_elem = content_div.find("small", class_="badge")
+            categories = []
+            if category_elem:
+                category_text = category_elem.get_text(strip=True)
+                categories = [category_text]
+
+            # Extract abstract
+            abstract_elem = content_div.find("p", class_="search-abstract")
+            abstract = abstract_elem.get_text(strip=True) if abstract_elem else ""
+
+            # Create paper object with search result data
+            published_date = updated_date if updated_date else datetime(1900, 1, 1)
+
+            return Paper(
+                paper_id=paper_id,
+                title=title,
+                authors=authors,
+                abstract=abstract,
+                url=paper_url,
+                pdf_url=pdf_url,
+                published_date=published_date,
+                updated_date=updated_date,
+                source="iacr",
+                categories=categories,
+                keywords=[],
+                doi="",
+                citations=0,
+            )
+
+        except Exception as e:
+            logger.warning(f"Failed to parse IACR paper: {e}")
+            return None
+
+    def search(
+        self, query: str, max_results: int = 10, fetch_details: bool = True
+    ) -> list[Paper]:
+        """
+        Search IACR ePrint Archive
+
+        Args:
+            query: Search query string
+            max_results: Maximum number of results to return
+            fetch_details: Whether to fetch detailed information for each paper (slower but more complete)
+
+        Returns:
+            List[Paper]: List of paper objects
+        """
+        papers = []
+
+        try:
+            # Construct search parameters
+            params = {"q": query}
+
+            # Make request
+            response = self.session.get(self.IACR_SEARCH_URL, params=params)
+
+            if response.status_code != 200:
+                logger.error(f"IACR search failed with status {response.status_code}")
+                return papers
+
+            # Parse results
+            soup = BeautifulSoup(response.text, "html.parser")
+
+            # Find all paper entries - they are divs with class "mb-4"
+            results = soup.find_all("div", class_="mb-4")
+
+            if not results:
+                logger.info("No results found for the query")
+                return papers
+
+            # Process each result
+            for i, item in enumerate(results):
+                if len(papers) >= max_results:
+                    break
+
+                logger.info(f"Processing paper {i+1}/{min(len(results), max_results)}")
+                paper = self._parse_paper(item, fetch_details=fetch_details)
+                if paper:
+                    papers.append(paper)
+
+        except Exception as e:
+            logger.error(f"IACR search error: {e}")
+
+        return papers[:max_results]
+
+    def download_pdf(self, paper_id: str, save_path: str) -> str:
+        """
+        Download PDF from IACR ePrint Archive
+
+        Args:
+            paper_id: IACR paper ID (e.g., "2025/1014")
+            save_path: Path to save the PDF
+
+        Returns:
+            str: Path to downloaded file or error message
+        """
+        try:
+            os.makedirs(save_path, exist_ok=True)
+            pdf_url = f"{self.IACR_BASE_URL}/{paper_id}.pdf"
+
+            response = self.session.get(pdf_url)
+
+            if response.status_code == 200:
+                filename = f"{save_path}/iacr_{paper_id.replace('/', '_')}.pdf"
+                with open(filename, "wb") as f:
+                    f.write(response.content)
+                return filename
+            else:
+                return f"Failed to download PDF: HTTP {response.status_code}"
+
+        except Exception as e:
+            logger.error(f"PDF download error: {e}")
+            return f"Error downloading PDF: {e}"
+
+    def read_paper(self, paper_id: str, save_path: str = "./downloads") -> str:
+        """
+        Download and extract text from IACR paper PDF
+
+        Args:
+            paper_id: IACR paper ID
+            save_path: Directory to save downloaded PDF
+
+        Returns:
+            str: Extracted text from the PDF or error message
+        """
+        try:
+            # First get paper details to get the PDF URL
+            paper = self.get_paper_details(paper_id)
+            if not paper or not paper.pdf_url:
+                return f"Error: Could not find PDF URL for paper {paper_id}"
+
+            # Download the PDF
+            pdf_response = requests.get(paper.pdf_url, timeout=30)
+            pdf_response.raise_for_status()
+
+            # Create download directory if it doesn't exist
+            os.makedirs(save_path, exist_ok=True)
+
+            # Save the PDF
+            filename = f"iacr_{paper_id.replace('/', '_')}.pdf"
+            pdf_path = os.path.join(save_path, filename)
+
+            with open(pdf_path, "wb") as f:
+                f.write(pdf_response.content)
+
+            # Extract text using pypdf
+            reader = PdfReader(pdf_path)
+            text = ""
+
+            for page_num, page in enumerate(reader.pages):
+                try:
+                    page_text = page.extract_text()
+                    if page_text:
+                        text += f"\n--- Page {page_num + 1} ---\n"
+                        text += page_text + "\n"
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to extract text from page {page_num + 1}: {e}"
+                    )
+                    continue
+
+            if not text.strip():
+                return (
+                    f"PDF downloaded to {pdf_path}, but unable to extract readable text"
+                )
+
+            # Add paper metadata at the beginning
+            metadata = f"Title: {paper.title}\n"
+            metadata += f"Authors: {', '.join(paper.authors)}\n"
+            metadata += f"Published Date: {paper.published_date}\n"
+            metadata += f"URL: {paper.url}\n"
+            metadata += f"PDF downloaded to: {pdf_path}\n"
+            metadata += "=" * 80 + "\n\n"
+
+            return metadata + text.strip()
+
+        except requests.RequestException as e:
+            logger.error(f"Error downloading PDF: {e}")
+            return f"Error downloading PDF: {e}"
+        except Exception as e:
+            logger.error(f"Read paper error: {e}")
+            return f"Error reading paper: {e}"
+
+    def get_paper_details(self, paper_id: str) -> Paper | None:
+        """
+        Fetch detailed information for a specific IACR paper
+
+        Args:
+            paper_id: IACR paper ID (e.g., "2009/101") or full URL
+
+        Returns:
+            Paper: Detailed paper object with full metadata
+        """
+        try:
+            # Handle both paper ID and full URL
+            if paper_id.startswith("http"):
+                paper_url = paper_id
+                # Extract paper ID from URL
+                parts = paper_url.split("/")
+                if len(parts) >= 2:
+                    paper_id = f"{parts[-2]}/{parts[-1]}"
+            else:
+                paper_url = f"{self.IACR_BASE_URL}/{paper_id}"
+
+            # Make request
+            response = self.session.get(paper_url)
+
+            if response.status_code != 200:
+                logger.error(
+                    f"Failed to fetch paper details: HTTP {response.status_code}"
+                )
+                return None
+
+            # Parse the page
+            soup = BeautifulSoup(response.text, "html.parser")
+
+            # Extract title from h3 element
+            title = ""
+            title_elem = soup.find("h3", class_="mb-3")
+            if title_elem:
+                title = title_elem.get_text(strip=True)
+
+            # Extract authors from the italic paragraph
+            authors = []
+            author_elem = soup.find("p", class_="fst-italic")
+            if author_elem:
+                author_text = author_elem.get_text(strip=True)
+                # Split by " and " to get individual authors
+                authors = [
+                    author.strip()
+                    for author in author_text.replace(" and ", ",").split(",")
+                ]
+
+            # Extract abstract using multiple strategies
+            abstract = ""
+
+            # Look for paragraph with white-space: pre-wrap style (current method)
+            abstract_p = soup.find("p", style="white-space: pre-wrap;")
+            if abstract_p:
+                abstract = abstract_p.get_text(strip=True)
+
+            # Extract metadata using a simpler, safer approach
+            publication_info = ""
+            keywords = []
+            history_entries = []
+            last_updated = None
+
+            # Extract publication info
+            page_text = soup.get_text()
+            lines = page_text.split("\n")
+
+            # Find publication info
+            for i, line in enumerate(lines):
+                if "Publication info" in line and i + 1 < len(lines):
+                    publication_info = lines[i + 1].strip()
+                    break
+
+            # Find keywords using CSS selector for keyword badges
+            try:
+                keyword_elements = soup.select("a.badge.bg-secondary.keyword")
+                keywords = [elem.get_text(strip=True) for elem in keyword_elements]
+            except Exception:
+                keywords = []
+
+            # Find history entries
+            history_found = False
+            for _i, line in enumerate(lines):
+                if "History" in line and ":" not in line:
+                    history_found = True
+                    continue
+                elif (
+                    history_found
+                    and ":" in line
+                    and not line.strip().startswith("Short URL")
+                ):
+                    history_entries.append(line.strip())
+                    # Try to extract the last updated date from the first history entry
+                    if not last_updated:
+                        date_str = line.split(":")[0].strip()
+                        try:
+                            last_updated = datetime.strptime(date_str, "%Y-%m-%d")
+                        except ValueError:
+                            pass
+                elif history_found and (
+                    line.strip().startswith("Short URL")
+                    or line.strip().startswith("License")
+                ):
+                    break
+
+            # Combine history entries
+            history = "; ".join(history_entries) if history_entries else ""
+
+            # Construct PDF URL
+            pdf_url = f"{self.IACR_BASE_URL}/{paper_id}.pdf"
+
+            # Use last updated date or current date as published date
+            published_date = last_updated if last_updated else datetime.now()
+
+            return Paper(
+                paper_id=paper_id,
+                title=title,
+                authors=authors,
+                abstract=abstract,
+                url=paper_url,
+                pdf_url=pdf_url,
+                published_date=published_date,
+                updated_date=last_updated,
+                source="iacr",
+                categories=[],
+                keywords=keywords,
+                doi="",
+                citations=0,
+                extra={"publication_info": publication_info, "history": history},
+            )
+
+        except Exception as e:
+            logger.error(f"Error fetching paper details for {paper_id}: {e}")
+            return None

all_in_mcp/paper.py

@@ -0,0 +1,64 @@
+# all_in_mcp/paper.py
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class Paper:
+    """Standardized paper format with core fields for academic sources"""
+
+    # Core fields (required, but allows empty values or defaults)
+    paper_id: str  # Unique identifier (e.g., arXiv ID, PMID, DOI)
+    title: str  # Paper title
+    authors: list[str]  # List of author names
+    abstract: str  # Abstract text
+    doi: str  # Digital Object Identifier
+    published_date: datetime  # Publication date
+    pdf_url: str  # Direct PDF link
+    url: str  # URL to paper page
+    source: str  # Source platform (e.g., 'arxiv', 'pubmed')
+
+    # Optional fields
+    updated_date: datetime | None = None  # Last updated date
+    categories: list[str] | None = None  # Subject categories
+    keywords: list[str] | None = None  # Keywords
+    citations: int = 0  # Citation count
+    references: list[str] | None = None  # List of reference IDs/DOIs
+    extra: dict | None = None  # Source-specific extra metadata
+
+    def __post_init__(self):
+        """Post-initialization to handle default values"""
+        if self.authors is None:
+            self.authors = []
+        if self.categories is None:
+            self.categories = []
+        if self.keywords is None:
+            self.keywords = []
+        if self.references is None:
+            self.references = []
+        if self.extra is None:
+            self.extra = {}
+
+    def to_dict(self) -> dict:
+        """Convert paper to dictionary format for serialization"""
+        return {
+            "paper_id": self.paper_id,
+            "title": self.title,
+            "authors": self.authors,
+            "abstract": self.abstract,
+            "doi": self.doi,
+            "published_date": (
+                self.published_date.isoformat() if self.published_date else None
+            ),
+            "pdf_url": self.pdf_url,
+            "url": self.url,
+            "source": self.source,
+            "updated_date": (
+                self.updated_date.isoformat() if self.updated_date else None
+            ),
+            "categories": self.categories,
+            "keywords": self.keywords,
+            "citations": self.citations,
+            "references": self.references,
+            "extra": self.extra,
+        }

all_in_mcp/server.py

@@ -0,0 +1,210 @@
+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
+
+# Import IACR searcher
+from .academic_platforms.iacr import IACRSearcher
+
+server = Server("all-in-mcp")
+
+# Initialize IACR searcher
+iacr_searcher = IACRSearcher()
+
+
+@server.list_tools()
+async def handle_list_tools() -> list[types.Tool]:
+    """
+    List available daily utility tools.
+    Each tool specifies its arguments using JSON Schema validation.
+    """
+    return [
+        types.Tool(
+            name="search-iacr-papers",
+            description="Search academic papers from IACR ePrint Archive",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query string (e.g., 'cryptography', 'secret sharing')",
+                    },
+                    "max_results": {
+                        "type": "integer",
+                        "description": "Maximum number of papers to return (default: 10)",
+                        "default": 10,
+                    },
+                    "fetch_details": {
+                        "type": "boolean",
+                        "description": "Whether to fetch detailed information for each paper (default: True)",
+                        "default": True,
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        types.Tool(
+            name="download-iacr-paper",
+            description="Download PDF of an IACR ePrint paper",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "paper_id": {
+                        "type": "string",
+                        "description": "IACR paper ID (e.g., '2009/101')",
+                    },
+                    "save_path": {
+                        "type": "string",
+                        "description": "Directory to save the PDF (default: './downloads')",
+                        "default": "./downloads",
+                    },
+                },
+                "required": ["paper_id"],
+            },
+        ),
+        types.Tool(
+            name="read-iacr-paper",
+            description="Read and extract text content from an IACR ePrint paper PDF",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "paper_id": {
+                        "type": "string",
+                        "description": "IACR paper ID (e.g., '2009/101')",
+                    },
+                    "save_path": {
+                        "type": "string",
+                        "description": "Directory where the PDF is/will be saved (default: './downloads')",
+                        "default": "./downloads",
+                    },
+                },
+                "required": ["paper_id"],
+            },
+        ),
+    ]
+
+
+@server.call_tool()
+async def handle_call_tool(
+    name: str, arguments: dict | None
+) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+    """
+    Handle tool execution requests.
+    """
+    if not arguments:
+        arguments = {}
+
+    try:
+        if name == "search-iacr-papers":
+            query = arguments.get("query", "")
+            max_results = arguments.get("max_results", 10)
+            fetch_details = arguments.get("fetch_details", True)
+
+            if not query:
+                return [
+                    types.TextContent(
+                        type="text", text="Error: Query parameter is required"
+                    )
+                ]
+
+            papers = iacr_searcher.search(query, max_results, fetch_details)
+
+            if not papers:
+                return [
+                    types.TextContent(
+                        type="text", text=f"No papers found for query: {query}"
+                    )
+                ]
+
+            # Format the results
+            result_text = f"Found {len(papers)} IACR papers for query '{query}':\n\n"
+            for i, paper in enumerate(papers, 1):
+                result_text += f"{i}. **{paper.title}**\n"
+                result_text += f"   - Paper ID: {paper.paper_id}\n"
+                result_text += f"   - Authors: {', '.join(paper.authors)}\n"
+                result_text += f"   - URL: {paper.url}\n"
+                result_text += f"   - PDF: {paper.pdf_url}\n"
+                if paper.categories:
+                    result_text += f"   - Categories: {', '.join(paper.categories)}\n"
+                if paper.keywords:
+                    result_text += f"   - Keywords: {', '.join(paper.keywords)}\n"
+                if paper.abstract:
+                    result_text += f"   - Abstract: {paper.abstract}n"
+                result_text += "\n"
+
+            return [types.TextContent(type="text", text=result_text)]
+
+        elif name == "download-iacr-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 = iacr_searcher.download_pdf(paper_id, save_path)
+
+            if result.startswith(("Error", "Failed")):
+                return [
+                    types.TextContent(type="text", text=f"Download failed: {result}")
+                ]
+            else:
+                return [
+                    types.TextContent(
+                        type="text", text=f"PDF downloaded successfully to: {result}"
+                    )
+                ]
+
+        elif name == "read-iacr-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 = iacr_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)]
+
+        else:
+            raise ValueError(f"Unknown tool: {name}")
+
+    except Exception as e:
+        return [types.TextContent(type="text", text=f"Error executing {name}: {e!s}")]
+
+
+async def main():
+    # Run the server using stdin/stdout streams
+    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="all-in-mcp",
+                server_version="0.1.0",
+                capabilities=server.get_capabilities(
+                    notification_options=NotificationOptions(),
+                    experimental_capabilities={},
+                ),
+            ),
+        )

all_in_mcp-0.1.4.dist-info/METADATA

@@ -0,0 +1,206 @@
+Metadata-Version: 2.4
+Name: all-in-mcp
+Version: 0.1.4
+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
+
+### Paper Search Capabilities
+
+- Search academic papers from IACR ePrint Archive
+- Download PDF files
+- Extract and read text content from papers
+- Metadata extraction (authors, publication dates, abstracts)
+
+## Quick Start
+
+### Prerequisites
+
+- Python 3.12 or higher
+- UV package manager
+
+## Installation
+
+### Option 1: Install from PyPI (Recommended)
+
+```bash
+pip install all-in-mcp
+```
+
+### Installation
+
+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
+- **[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.1.4.dist-info/RECORD

@@ -0,0 +1,11 @@
+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=HHopmtcjoCLlmcf2P3DWlj0pn42fjQ1L0UF44WHK6Mw,7604
+all_in_mcp/academic_platforms/__init__.py,sha256=FbxJcL8B7hP0KjBvtanNuvt6qfla3B_q-KjxdjnxukY,44
+all_in_mcp/academic_platforms/base.py,sha256=VYMp8_tnp7YzXKAXLfr7uUxgvJBNKRyC_NT1uVhBOwY,673
+all_in_mcp/academic_platforms/iacr.py,sha256=MUPxFycVS0eMsJok71y12RUqjxbRrCReG33V5ORAbfU,15450
+all_in_mcp-0.1.4.dist-info/METADATA,sha256=tTuprD0AU0V0qhuDwg4vgQRHEuvga5tS-i29tGVFyOk,5219
+all_in_mcp-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+all_in_mcp-0.1.4.dist-info/entry_points.txt,sha256=FbQOtUQzOIfkMNp4qQV1NTU9K4J7C0XGH9wKKhfK1VM,47
+all_in_mcp-0.1.4.dist-info/licenses/LICENSE,sha256=idExTHItK7AC5FVo4H9HKnr6h51Z8BKCEztZPyP8nK8,1062
+all_in_mcp-0.1.4.dist-info/RECORD,,

all_in_mcp-0.1.4.dist-info/WHEEL

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

all_in_mcp-0.1.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+all-in-mcp = all_in_mcp:main

all_in_mcp-0.1.4.dist-info/licenses/LICENSE

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