all-in-mcp 0.1.4__tar.gz → 0.2.2__tar.gz

{all_in_mcp-0.1.4 → all_in_mcp-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: all-in-mcp
-Version: 0.1.4
+Version: 0.2.2
 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,24 @@ 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
 
 ### 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 +85,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 +211,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.1.4 → all_in_mcp-0.2.2}/README.md

@@ -7,14 +7,24 @@ 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
 
 ### 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
@@ -30,7 +40,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:
 
@@ -156,6 +166,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.1.4 → all_in_mcp-0.2.2}/docs/api.md

@@ -108,6 +108,61 @@ URL: https://eprint.iacr.org/2023/1234
 [Full extracted text content]
 ```
 
+## CryptoBib Bibliography Search
+
+### search-cryptobib-papers
+
+Search CryptoBib bibliography database for cryptography papers. CryptoBib is a comprehensive BibTeX database of cryptography-related academic papers.
+
+**Parameters:**
+
+- `query` (string, required): Search query string (e.g., 'cryptography', 'lattice', 'homomorphic')
+- `max_results` (integer, optional): Maximum number of results to return (default: 10)
+- `return_bibtex` (boolean, optional): Whether to return raw BibTeX entries (default: false)
+- `force_download` (boolean, optional): Force download the newest crypto.bib file (default: false)
+
+**Returns:**
+
+- List of papers with metadata or raw BibTeX entries
+
+**Example:**
+
+```json
+{
+  "name": "search-cryptobib-papers",
+  "arguments": {
+    "query": "lattice cryptography",
+    "max_results": 5,
+    "return_bibtex": true,
+    "force_download": false
+  }
+}
+```
+
+**Response:**
+
+````text
+Found 5 BibTeX entries for query 'lattice cryptography':
+
+Entry 1:
+```bibtex
+@InProceedings{CRYPTO:RegLyr05,
+  author = "Oded Regev and Ricky Steinfeld",
+  title = "Learning With Errors over Rings",
+  booktitle = "CRYPTO 2005",
+  year = 2005,
+  ...
+}
+````
+
+**Important Notes:**
+
+- **First Use**: On first use, the tool will download the crypto.bib file (~50MB) and cache it locally in the `./downloads` directory
+- **Caching**: Subsequent searches use the cached file unless `force_download` is set to true
+- **BibTeX Retrieval**: To get specific BibTeX entries, use the `search-cryptobib-papers` tool with `return_bibtex=true` and a specific search query
+- **Content**: The crypto.bib file contains thousands of cryptography-related papers from major conferences and journals
+- **Performance**: Local file searching is much faster than streaming searches
+
 ## Error Handling
 
 All tools return error messages in case of failures:

all_in_mcp-0.2.2/docs/cryptobib.md

@@ -0,0 +1,166 @@
+# CryptoBib Integration
+
+This document describes the CryptoBib integration in the all-in-mcp server.
+
+## Overview
+
+CryptoBib (https://cryptobib.di.ens.fr/) is a comprehensive bibliography database for cryptography research papers. This integration allows searching through the CryptoBib database and retrieving BibTeX entries.
+
+## Features
+
+### Search Functionality
+
+- Search through the entire CryptoBib database
+- Case-insensitive search across all BibTeX fields
+- Returns both parsed Paper objects and raw BibTeX entries
+- Configurable result limits
+
+### BibTeX Support
+
+- Parse BibTeX entries into structured Paper objects
+- Retrieve raw BibTeX entries for direct use
+- Support for all standard BibTeX fields (author, title, booktitle, journal, year, etc.)
+- Clean LaTeX formatting from titles and authors
+
+## Available Tools
+
+### search-cryptobib-papers
+
+Search CryptoBib bibliography database for cryptography papers.
+
+**Parameters:**
+
+- `query` (required): Search query string (e.g., 'lattice', 'homomorphic encryption')
+- `max_results` (optional, default: 10): Maximum number of results to return
+- `return_bibtex` (optional, default: false): Whether to return raw BibTeX entries
+- `force_download` (optional, default: false): Force download the newest crypto.bib file
+
+**Examples:**
+
+```json
+{
+  "query": "lattice cryptography",
+  "max_results": 5,
+  "return_bibtex": false
+}
+```
+
+To get specific BibTeX entries, you can use targeted search queries with `return_bibtex=true`.
+
+## Usage Examples
+
+### Basic Search
+
+```python
+from all_in_mcp.academic_platforms.cryptobib import CryptoBibSearcher
+
+searcher = CryptoBibSearcher()
+
+# Search for papers
+papers = searcher.search("homomorphic encryption", max_results=5)
+for paper in papers:
+    print(f"Title: {paper.title}")
+    print(f"Authors: {', '.join(paper.authors)}")
+    print(f"BibTeX Key: {paper.paper_id}")
+```
+
+### Get Raw BibTeX
+
+```python
+# Get raw BibTeX entries
+bibtex_entries = searcher.search_bibtex("zero knowledge", max_results=3)
+for entry in bibtex_entries:
+    print(entry)
+```
+
+### Get Specific BibTeX Entry
+
+```python
+# Search for specific entries using targeted queries
+papers = searcher.search("ACISP:LZXSW24", max_results=1)
+if papers:
+    # Access the BibTeX from the paper's extra field
+    bibtex = papers[0].extra.get('bibtex', '')
+    print(bibtex)
+
+# Or get raw BibTeX entries directly
+bibtex_entries = searcher.search_bibtex("ACISP:LZXSW24", max_results=1)
+if bibtex_entries:
+    print(bibtex_entries[0])
+```
+
+## BibTeX Entry Format
+
+CryptoBib uses standard BibTeX format. Example entry:
+
+```bibtex
+@InProceedings{ACISP:LZXSW24,
+  author =       "Fangzhou Liu and
+                  Xueqi Zhu and
+                  Ruozhou Xu and
+                  Danping Shi and
+                  Peng Wang",
+  title =        "The Offline Quantum Attack Against Modular Addition Variant of {Even}-{Mansour} Cipher",
+  pages =        "3--19",
+  editor =       acisp24ed,
+  booktitle =    acisp24name1,
+  volume =       acisp24vol1,
+  address =      acisp24addr,
+  month =        acisp24month,
+  publisher =    acisp24pub,
+  series =       mylncs,
+  year =         2024,
+  doi =          "10.1007/978-981-97-5025-2_1",
+}
+```
+
+## Implementation Details
+
+### Search Strategy
+
+The implementation uses streaming HTTP requests to search through the large crypto.bib file without downloading it entirely. It:
+
+1. Makes a streaming request to the crypto.bib file
+2. Parses BibTeX entries on-the-fly
+3. Performs case-insensitive matching against the search query
+4. Returns results as they are found up to the specified limit
+
+### Performance Considerations
+
+- Uses streaming to avoid memory issues with the large bibliography file
+- Processes entries incrementally
+- Stops searching once the maximum number of results is reached
+- Implements proper brace counting for correct BibTeX entry parsing
+
+### Limitations
+
+- No PDF download capability (CryptoBib is a bibliography database only)
+- No full-text search of paper content
+- Search is limited to BibTeX field content
+- Dependent on CryptoBib server availability
+
+## Testing
+
+Run the CryptoBib tests:
+
+```bash
+# Run all tests
+pytest tests/test_cryptobib.py
+
+# Run with verbose output
+pytest tests/test_cryptobib.py -v
+
+# Test specific functionality
+python test_cryptobib.py
+```
+
+## Error Handling
+
+The implementation includes comprehensive error handling for:
+
+- Network connectivity issues
+- Malformed BibTeX entries
+- Server response errors
+- Parsing failures
+
+All errors are logged and gracefully handled, returning empty results or error messages as appropriate.

{all_in_mcp-0.1.4 → all_in_mcp-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "all-in-mcp"
-version = "0.1.4"
+version = "0.2.2"
 description = "An MCP (Model Context Protocol) server providing daily-use utility functions and academic paper search capabilities"
 readme = "README.md"
 license = { text = "MIT" }

all_in_mcp-0.2.2/src/all_in_mcp/academic_platforms/__init__.py

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

all_in_mcp-0.2.2/src/all_in_mcp/academic_platforms/cryptobib.py

@@ -0,0 +1,461 @@
+# all_in_mcp/academic_platforms/cryptobib.py
+import logging
+import os
+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
+            normalized_text = 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, "r", 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, "r", encoding="utf-8") as f:
+                for line in f:
+                    # Check if this is the start of the entry we're looking for
+                    if line.strip().startswith(f"@") and entry_key in line:
+                        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-0.1.4 → all_in_mcp-0.2.2}/src/all_in_mcp/server.py

@@ -5,13 +5,15 @@ import mcp.types as types
 from mcp.server import NotificationOptions, Server
 from mcp.server.models import InitializationOptions
 
-# Import IACR searcher
+# Import searchers
 from .academic_platforms.iacr import IACRSearcher
+from .academic_platforms.cryptobib import CryptoBibSearcher
 
 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,43 @@ 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"],
+            },
+        ),
     ]
 
 
@@ -186,6 +225,104 @@ 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)]
+
         else:
             raise ValueError(f"Unknown tool: {name}")
 

all_in_mcp-0.1.4/src/all_in_mcp/academic_platforms/__init__.py

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