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

all_in_mcp/academic_platforms/__init__.py

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

all_in_mcp/academic_platforms/cryptobib.py

@@ -0,0 +1,460 @@
+# all_in_mcp/academic_platforms/cryptobib.py
+import logging
+import random
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import ClassVar
+
+import requests
+
+from ..paper import Paper
+from .base import PaperSource
+
+logger = logging.getLogger(__name__)
+
+
+class CryptoBibSearcher(PaperSource):
+    """CryptoBib (https://cryptobib.di.ens.fr/) bibliography search implementation"""
+
+    CRYPTOBIB_BASE_URL = "https://cryptobib.di.ens.fr"
+    CRYPTOBIB_BIB_URL = "https://cryptobib.di.ens.fr/cryptobib/static/files/crypto.bib"
+    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, cache_dir: str = "./downloads"):
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(exist_ok=True)
+        self.bib_file_path = self.cache_dir / "crypto.bib"
+        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/plain,text/html,application/xhtml+xml",
+                "Accept-Language": "en-US,en;q=0.9",
+            }
+        )
+
+    def _download_bib_file(self, force_download: bool = False) -> bool:
+        """
+        Download the crypto.bib file if not exists or if force_download is True
+
+        Args:
+            force_download: Force download even if file exists
+
+        Returns:
+            bool: True if file is ready, False if download failed
+        """
+        try:
+            # Check if file exists and force_download is False
+            if self.bib_file_path.exists() and not force_download:
+                logger.info(f"Using cached crypto.bib file at {self.bib_file_path}")
+                return True
+
+            logger.info("Downloading crypto.bib file from CryptoBib...")
+            response = self.session.get(self.CRYPTOBIB_BIB_URL, stream=True)
+
+            if response.status_code != 200:
+                logger.error(
+                    f"Failed to download crypto.bib: HTTP {response.status_code}"
+                )
+                return False
+
+            # Download with progress indication
+            total_size = int(response.headers.get("content-length", 0))
+            downloaded = 0
+
+            with open(self.bib_file_path, "wb") as f:
+                for chunk in response.iter_content(
+                    chunk_size=1024 * 1024
+                ):  # 1MB chunks
+                    if chunk:
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        if total_size > 0:
+                            progress = (downloaded / total_size) * 100
+                            if downloaded % (1024 * 1024 * 5) == 0:  # Log every 5MB
+                                logger.info(f"Download progress: {progress:.1f}%")
+
+            logger.info(f"Successfully downloaded crypto.bib to {self.bib_file_path}")
+            return True
+
+        except requests.RequestException as e:
+            logger.error(f"Error downloading crypto.bib: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Unexpected error downloading crypto.bib: {e}")
+            return False
+
+    def _parse_bibtex_entry(self, bibtex_text: str) -> Paper | None:
+        """Parse a single BibTeX entry into a Paper object"""
+        try:
+            # Extract entry type and key
+            entry_match = re.match(r"@(\w+){([^,]+),", bibtex_text, re.IGNORECASE)
+            if not entry_match:
+                return None
+
+            entry_type = entry_match.group(1).lower()
+            entry_key = entry_match.group(2).strip()
+
+            # Initialize fields
+            title = ""
+            authors = []
+            year = None
+            booktitle = ""
+            journal = ""
+            pages = ""
+            doi = ""
+            url = ""
+            abstract = ""
+
+            # Extract fields using a more robust approach
+            # First, normalize the text by removing extra whitespace
+            re.sub(r"\s+", " ", bibtex_text)
+
+            # Extract fields with better pattern matching
+            field_dict = {}
+
+            # Pattern for quoted fields (handles multi-line)
+            quoted_pattern = r'(\w+)\s*=\s*"([^"]*(?:[^"\\]|\\.)*)"'
+            for match in re.finditer(quoted_pattern, bibtex_text, re.DOTALL):
+                field_name = match.group(1).lower().strip()
+                field_value = match.group(2).strip()
+                field_dict[field_name] = field_value
+
+            # Pattern for unquoted fields (like numbers)
+            unquoted_pattern = r'(\w+)\s*=\s*([^,}\n"]+)'
+            for match in re.finditer(unquoted_pattern, bibtex_text):
+                field_name = match.group(1).lower().strip()
+                field_value = match.group(2).strip()
+                # Only add if not already present from quoted pattern
+                if field_name not in field_dict:
+                    field_dict[field_name] = field_value
+
+            for field_name, field_value in field_dict.items():
+                field_name = field_name.lower().strip()
+                field_value = field_value.strip()
+
+                if field_name == "title":
+                    # Clean up title (remove LaTeX commands)
+                    title = re.sub(r"[{}]", "", field_value)
+                    title = re.sub(r"\\[a-zA-Z]+", "", title)
+                    title = title.strip()
+
+                elif field_name == "author":
+                    # Parse authors - handle "and" separator
+                    author_text = re.sub(r"[{}]", "", field_value)
+                    authors = [
+                        author.strip()
+                        for author in re.split(r"\s+and\s+", author_text)
+                        if author.strip()
+                    ]
+
+                elif field_name == "year":
+                    try:
+                        year = int(field_value)
+                    except ValueError:
+                        pass
+
+                elif field_name == "booktitle":
+                    booktitle = re.sub(r"[{}]", "", field_value)
+
+                elif field_name == "journal":
+                    journal = re.sub(r"[{}]", "", field_value)
+
+                elif field_name == "pages":
+                    pages = field_value
+
+                elif field_name == "doi":
+                    doi = field_value
+
+                elif field_name == "url":
+                    url = field_value
+
+                elif field_name == "abstract":
+                    abstract = field_value
+
+            # Determine venue (journal or conference)
+            venue = journal if journal else booktitle
+            categories = [entry_type] if entry_type else []
+
+            # Create published date
+            published_date = datetime(year, 1, 1) if year else datetime(1900, 1, 1)
+
+            return Paper(
+                paper_id=entry_key,
+                title=title,
+                authors=authors,
+                abstract=abstract,
+                url=url,
+                pdf_url="",  # CryptoBib doesn't provide PDF URLs
+                published_date=published_date,
+                updated_date=None,
+                source="cryptobib",
+                categories=categories,
+                keywords=[],
+                doi=doi,
+                citations=0,
+                extra={
+                    "bibtex": bibtex_text.strip(),
+                    "venue": venue,
+                    "pages": pages,
+                    "entry_type": entry_type,
+                },
+            )
+
+        except Exception as e:
+            logger.warning(f"Failed to parse BibTeX entry: {e}")
+            return None
+
+    def search_bibtex(
+        self,
+        query: str,
+        max_results: int = 10,
+        force_download: bool = False,
+        year_min: int | None = None,
+        year_max: int | None = None,
+    ) -> list[str]:
+        """
+        Search CryptoBib and return raw BibTeX entries
+
+        Args:
+            query: Search query string
+            max_results: Maximum number of results to return
+            force_download: Force download the newest crypto.bib file
+            year_min: Minimum publication year (inclusive, optional)
+            year_max: Maximum publication year (inclusive, optional)
+
+        Returns:
+            List[str]: List of BibTeX entries as strings
+
+        Example:
+            >>> searcher = CryptoBibSearcher()
+            >>> # Search for recent implementation papers (2020-2024)
+            >>> entries = searcher.search_bibtex("implement", max_results=5,
+            ...                                 year_min=2020, year_max=2024)
+            >>>
+            >>> # Search for older RSA papers (1980-2000)
+            >>> entries = searcher.search_bibtex("RSA", max_results=10,
+            ...                                 year_min=1980, year_max=2000)
+        """
+        bibtex_entries = []
+
+        try:
+            # Ensure we have the bib file locally
+            if not self._download_bib_file(force_download=force_download):
+                logger.error("Failed to download crypto.bib file")
+                return bibtex_entries
+
+            # Search in the local file
+            logger.info(f"Searching local crypto.bib file for: {query}")
+            current_entry = ""
+            in_entry = False
+            brace_count = 0
+
+            # Convert query to lowercase for case-insensitive search
+            query_lower = query.lower()
+
+            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:
+                        current_entry = line
+                        in_entry = True
+                        brace_count = line.count("{") - line.count("}")
+                    elif in_entry:
+                        current_entry += line
+                        brace_count += line.count("{") - line.count("}")
+
+                        # Check if entry is complete
+                        if brace_count <= 0:
+                            # Entry is complete, check if it matches the query
+                            if query_lower in current_entry.lower():
+                                # Check year range if specified
+                                if self._entry_matches_year_range(
+                                    current_entry, year_min, year_max
+                                ):
+                                    bibtex_entries.append(current_entry.strip())
+                                    logger.info(
+                                        f"Found matching entry {len(bibtex_entries)} at line {line_num}"
+                                    )
+
+                                    if len(bibtex_entries) >= max_results:
+                                        break
+
+                            # Reset for next entry
+                            current_entry = ""
+                            in_entry = False
+                            brace_count = 0
+
+        except FileNotFoundError:
+            logger.error(f"crypto.bib file not found at {self.bib_file_path}")
+        except Exception as e:
+            logger.error(f"CryptoBib search error: {e}")
+
+        return bibtex_entries[:max_results]
+
+    def search(
+        self,
+        query: str,
+        max_results: int = 10,
+        return_bibtex: bool = False,
+        force_download: bool = False,
+        year_min: int | None = None,
+        year_max: int | None = None,
+    ) -> list[Paper]:
+        """
+        Search CryptoBib bibliography
+
+        Args:
+            query: Search query string
+            max_results: Maximum number of results to return
+            return_bibtex: If True, include raw BibTeX in results
+            force_download: Force download the newest crypto.bib file
+            year_min: Minimum publication year (inclusive, optional)
+            year_max: Maximum publication year (inclusive, optional)
+
+        Returns:
+            List[Paper]: List of paper objects
+
+        Example:
+            >>> searcher = CryptoBibSearcher()
+            >>> # Search for recent zero-knowledge papers (2020-2024)
+            >>> papers = searcher.search("zero knowledge", max_results=5,
+            ...                         year_min=2020, year_max=2024)
+            >>>
+            >>> # Search for classic RSA papers (1977-1990)
+            >>> papers = searcher.search("RSA", max_results=10,
+            ...                         year_min=1977, year_max=1990)
+        """
+        papers = []
+
+        try:
+            # Get BibTeX entries
+            bibtex_entries = self.search_bibtex(
+                query,
+                max_results,
+                force_download=force_download,
+                year_min=year_min,
+                year_max=year_max,
+            )
+
+            # Parse each entry into Paper objects
+            for i, bibtex_text in enumerate(bibtex_entries):
+                logger.info(f"Parsing entry {i+1}/{len(bibtex_entries)}")
+                paper = self._parse_bibtex_entry(bibtex_text)
+                if paper:
+                    papers.append(paper)
+
+        except Exception as e:
+            logger.error(f"CryptoBib search error: {e}")
+
+        return papers
+
+    def download_pdf(self, paper_id: str, save_path: str) -> str:
+        """
+        CryptoBib doesn't provide PDF downloads
+        """
+        return "Error: CryptoBib is a bibliography database and doesn't provide PDF downloads"
+
+    def read_paper(self, paper_id: str, save_path: str = "./downloads") -> str:
+        """
+        CryptoBib doesn't provide paper content reading
+        """
+        return "Error: CryptoBib is a bibliography database and doesn't provide paper content"
+
+    def get_bibtex_by_key(
+        self, entry_key: str, force_download: bool = False
+    ) -> str | None:
+        """
+        Get a specific BibTeX entry by its key
+
+        Args:
+            entry_key: The BibTeX entry key (e.g., "ACISP:LZXSW24")
+            force_download: Force download the newest crypto.bib file
+
+        Returns:
+            str: The BibTeX entry or None if not found
+        """
+        try:
+            # Ensure we have the bib file locally
+            if not self._download_bib_file(force_download=force_download):
+                logger.error("Failed to download crypto.bib file")
+                return None
+
+            logger.info(f"Searching for BibTeX entry: {entry_key}")
+            current_entry = ""
+            in_entry = False
+            brace_count = 0
+
+            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("@") and entry_key in line:
+                        current_entry = line
+                        in_entry = True
+                        brace_count = line.count("{") - line.count("}")
+                    elif in_entry:
+                        current_entry += line
+                        brace_count += line.count("{") - line.count("}")
+
+                        # Check if entry is complete
+                        if brace_count <= 0:
+                            return current_entry.strip()
+
+        except FileNotFoundError:
+            logger.error(f"crypto.bib file not found at {self.bib_file_path}")
+        except Exception as e:
+            logger.error(f"Error searching for entry {entry_key}: {e}")
+
+        return None
+
+    def _entry_matches_year_range(
+        self, bibtex_entry: str, year_min: int | None, year_max: int | None
+    ) -> bool:
+        """
+        Check if a BibTeX entry falls within the specified year range
+
+        Args:
+            bibtex_entry: Raw BibTeX entry text
+            year_min: Minimum year (inclusive, None means no minimum)
+            year_max: Maximum year (inclusive, None means no maximum)
+
+        Returns:
+            bool: True if entry is within year range, False otherwise
+        """
+        # If no year constraints specified, all entries match
+        if year_min is None and year_max is None:
+            return True
+
+        try:
+            # Extract year from the BibTeX entry
+            year_match = re.search(
+                r'year\s*=\s*(?:["{\s]*)?(\d{4})', bibtex_entry, re.IGNORECASE
+            )
+            if not year_match:
+                # If no year found, exclude from results when year filtering is requested
+                return False
+
+            entry_year = int(year_match.group(1))
+
+            # Check minimum year constraint
+            if year_min is not None and entry_year < year_min:
+                return False
+
+            # Check maximum year constraint
+            if year_max is not None and entry_year > year_max:
+                return False
+
+            return True
+
+        except (ValueError, AttributeError):
+            # If year parsing fails, exclude from results when year filtering is requested
+            return False

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,17 +1,19 @@
-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.cryptobib import CryptoBibSearcher
+
+# Import searchers
 from .academic_platforms.iacr import IACRSearcher
+from .paper import read_pdf
 
 server = Server("all-in-mcp")
 
-# Initialize IACR searcher
+# Initialize searchers
 iacr_searcher = IACRSearcher()
+cryptobib_searcher = CryptoBibSearcher(cache_dir="./downloads")
 
 
 @server.list_tools()
@@ -83,6 +85,57 @@ async def handle_list_tools() -> list[types.Tool]:
                 "required": ["paper_id"],
             },
         ),
+        types.Tool(
+            name="search-cryptobib-papers",
+            description="Search CryptoBib bibliography database for cryptography papers",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query string (e.g., 'cryptography', 'lattice', 'homomorphic')",
+                    },
+                    "max_results": {
+                        "type": "integer",
+                        "description": "Maximum number of papers to return (default: 10)",
+                        "default": 10,
+                    },
+                    "return_bibtex": {
+                        "type": "boolean",
+                        "description": "Whether to return raw BibTeX entries (default: False)",
+                        "default": False,
+                    },
+                    "force_download": {
+                        "type": "boolean",
+                        "description": "Force download the newest crypto.bib file (default: False)",
+                        "default": False,
+                    },
+                    "year_min": {
+                        "type": "integer",
+                        "description": "Minimum publication year (inclusive, optional)",
+                    },
+                    "year_max": {
+                        "type": "integer",
+                        "description": "Maximum publication year (inclusive, optional)",
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        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"],
+            },
+        ),
     ]
 
 
@@ -186,6 +239,125 @@ async def handle_call_tool(
                 else:
                     return [types.TextContent(type="text", text=result)]
 
+        elif name == "search-cryptobib-papers":
+            query = arguments.get("query", "")
+            max_results = arguments.get("max_results", 10)
+            return_bibtex = arguments.get("return_bibtex", False)
+            force_download = arguments.get("force_download", False)
+            year_min = arguments.get("year_min")
+            year_max = arguments.get("year_max")
+
+            if not query:
+                return [
+                    types.TextContent(
+                        type="text", text="Error: Query parameter is required"
+                    )
+                ]
+
+            if return_bibtex:
+                # Return raw BibTeX entries
+                bibtex_entries = cryptobib_searcher.search_bibtex(
+                    query,
+                    max_results,
+                    force_download=force_download,
+                    year_min=year_min,
+                    year_max=year_max,
+                )
+
+                if not bibtex_entries:
+                    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 BibTeX entries 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(bibtex_entries)} BibTeX entries for query '{query}'{year_filter_msg}:\n\n"
+                for i, entry in enumerate(bibtex_entries, 1):
+                    result_text += f"Entry {i}:\n```bibtex\n{entry}\n```\n\n"
+
+                return [types.TextContent(type="text", text=result_text)]
+            else:
+                # Return parsed Paper objects
+                papers = cryptobib_searcher.search(
+                    query,
+                    max_results,
+                    force_download=force_download,
+                    year_min=year_min,
+                    year_max=year_max,
+                )
+
+                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)} CryptoBib 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"   - Entry Key: {paper.paper_id}\n"
+                    result_text += f"   - Authors: {', '.join(paper.authors)}\n"
+                    if paper.extra and "venue" in paper.extra:
+                        result_text += f"   - Venue: {paper.extra['venue']}\n"
+                    if paper.published_date and paper.published_date.year > 1900:
+                        result_text += f"   - Year: {paper.published_date.year}\n"
+                    if paper.doi:
+                        result_text += f"   - DOI: {paper.doi}\n"
+                    if paper.extra and "pages" in paper.extra:
+                        result_text += f"   - Pages: {paper.extra['pages']}\n"
+                    # Only include BibTeX when explicitly requested
+                    if return_bibtex and paper.extra and "bibtex" in paper.extra:
+                        result_text += (
+                            f"   - BibTeX:\n```bibtex\n{paper.extra['bibtex']}\n```\n"
+                        )
+                    result_text += "\n"
+
+                return [types.TextContent(type="text", text=result_text)]
+
+        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.1.4.dist-info → all_in_mcp-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: all-in-mcp
-Version: 0.1.4
+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
@@ -52,14 +52,25 @@ An MCP (Model Context Protocol) server that provides daily-use utility functions
 ### 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
@@ -75,7 +86,7 @@ An MCP (Model Context Protocol) server that provides daily-use utility functions
 pip install all-in-mcp
 ```
 
-### Installation
+### Option 2: Install from Source
 
 1. Clone this repository:
 
@@ -201,6 +212,7 @@ 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

@@ -0,0 +1,12 @@
+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,,

all_in_mcp-0.1.4.dist-info/RECORD

@@ -1,11 +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=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,,