scitex 2.15.3__py3-none-any.whl → 2.15.5__py3-none-any.whl

scitex/scholar/_mcp/crossref_tool_schemas.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-29
+# File: src/scitex/scholar/_mcp/crossref_tool_schemas.py
+"""CrossRef-Local tool schemas for MCP server.
+
+Provides access to 167M+ papers via crossref-local database.
+"""
+
+from __future__ import annotations
+
+import mcp.types as types
+
+__all__ = ["get_crossref_tool_schemas"]
+
+
+def get_crossref_tool_schemas() -> list[types.Tool]:
+    """Return CrossRef-Local tool schemas."""
+    return [
+        types.Tool(
+            name="crossref_search",
+            description=(
+                "Search CrossRef database (167M+ papers) via crossref-local. "
+                "Fast full-text search with year filtering and citation enrichment."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query string (full-text search)",
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of results",
+                        "default": 20,
+                    },
+                    "offset": {
+                        "type": "integer",
+                        "description": "Number of results to skip for pagination",
+                        "default": 0,
+                    },
+                    "year_min": {
+                        "type": "integer",
+                        "description": "Minimum publication year filter",
+                    },
+                    "year_max": {
+                        "type": "integer",
+                        "description": "Maximum publication year filter",
+                    },
+                    "enrich": {
+                        "type": "boolean",
+                        "description": "Add citation counts and references",
+                        "default": False,
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        types.Tool(
+            name="crossref_get",
+            description="Get a paper by DOI from CrossRef database with optional citation data.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "doi": {
+                        "type": "string",
+                        "description": "DOI of the paper (e.g., '10.1038/nature12373')",
+                    },
+                    "include_citations": {
+                        "type": "boolean",
+                        "description": "Include list of DOIs that cite this paper",
+                        "default": False,
+                    },
+                    "include_references": {
+                        "type": "boolean",
+                        "description": "Include list of DOIs this paper references",
+                        "default": False,
+                    },
+                },
+                "required": ["doi"],
+            },
+        ),
+        types.Tool(
+            name="crossref_count",
+            description="Count papers matching a search query in CrossRef database.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query string",
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        types.Tool(
+            name="crossref_citations",
+            description="Get citation relationships for a paper (citing papers and/or references).",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "doi": {
+                        "type": "string",
+                        "description": "DOI of the paper",
+                    },
+                    "direction": {
+                        "type": "string",
+                        "description": "Citation direction: 'citing', 'cited', or 'both'",
+                        "enum": ["citing", "cited", "both"],
+                        "default": "citing",
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum results per direction",
+                        "default": 100,
+                    },
+                },
+                "required": ["doi"],
+            },
+        ),
+        types.Tool(
+            name="crossref_info",
+            description="Get CrossRef database configuration and status.",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
+    ]
+
+
+# EOF

scitex/scholar/_mcp/openalex_handlers.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-29
+# File: src/scitex/scholar/_mcp/openalex_handlers.py
+"""OpenAlex-SciTeX handler implementations via openalex-local delegation.
+
+These handlers delegate to openalex-local for fast access to 250M+ papers.
+Branded as openalex-scitex to distinguish from official OpenAlex API.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime
+
+__all__ = [
+    "openalex_search_handler",
+    "openalex_get_handler",
+    "openalex_count_handler",
+    "openalex_info_handler",
+]
+
+
+def _ensure_openalex():
+    """Ensure openalex_scitex module is available."""
+    try:
+        from scitex.scholar import openalex_scitex
+
+        return openalex_scitex
+    except ImportError as e:
+        raise RuntimeError(
+            "openalex-local not installed. Install with: pip install openalex-local"
+        ) from e
+
+
+async def openalex_search_handler(
+    query: str,
+    limit: int = 20,
+    offset: int = 0,
+    year_min: int | None = None,
+    year_max: int | None = None,
+) -> dict:
+    """Search OpenAlex database (250M+ papers) via openalex-local.
+
+    Args:
+        query: Search query string (full-text search)
+        limit: Maximum number of results (default: 20)
+        offset: Number of results to skip for pagination
+        year_min: Minimum publication year filter
+        year_max: Maximum publication year filter
+    """
+    try:
+        openalex = _ensure_openalex()
+        loop = asyncio.get_running_loop()
+
+        def do_search():
+            # Fetch more results for filtering
+            fetch_limit = limit * 2 if (year_min or year_max) else limit
+            results = openalex.search(query, limit=fetch_limit, offset=offset)
+
+            papers = []
+            for work in results:
+                # Apply year filters
+                if year_min and work.year and work.year < year_min:
+                    continue
+                if year_max and work.year and work.year > year_max:
+                    continue
+
+                papers.append(
+                    {
+                        "doi": work.doi,
+                        "title": work.title,
+                        "authors": work.authors[:10] if work.authors else [],
+                        "year": work.year,
+                        "journal": work.journal,
+                        "abstract": (
+                            work.abstract[:500] + "..."
+                            if work.abstract and len(work.abstract) > 500
+                            else work.abstract
+                        ),
+                        "citation_count": getattr(work, "citation_count", None),
+                        "reference_count": getattr(work, "reference_count", None),
+                        "type": getattr(work, "type", None),
+                        "openalex_id": getattr(work, "openalex_id", None),
+                    }
+                )
+                if len(papers) >= limit:
+                    break
+
+            return papers, getattr(results, "total", len(papers))
+
+        papers, total = await loop.run_in_executor(None, do_search)
+
+        return {
+            "success": True,
+            "query": query,
+            "total": total,
+            "count": len(papers),
+            "offset": offset,
+            "limit": limit,
+            "papers": papers,
+            "source": "openalex_local",
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+async def openalex_get_handler(
+    doi: str = None,
+    openalex_id: str = None,
+) -> dict:
+    """Get a paper by DOI or OpenAlex ID from OpenAlex database.
+
+    Args:
+        doi: DOI of the paper (e.g., '10.1038/nature12373')
+        openalex_id: OpenAlex ID (e.g., 'W2100837269')
+    """
+    if not doi and not openalex_id:
+        return {"success": False, "error": "Must provide either doi or openalex_id"}
+
+    try:
+        openalex = _ensure_openalex()
+        loop = asyncio.get_running_loop()
+
+        def do_get():
+            identifier = doi or openalex_id
+            work = openalex.get(identifier)
+            if not work:
+                return None
+
+            result = {
+                "doi": work.doi,
+                "title": work.title,
+                "authors": work.authors,
+                "year": work.year,
+                "journal": work.journal,
+                "abstract": work.abstract,
+                "citation_count": getattr(work, "citation_count", None),
+                "reference_count": getattr(work, "reference_count", None),
+                "type": getattr(work, "type", None),
+                "openalex_id": getattr(work, "openalex_id", None),
+                "publisher": getattr(work, "publisher", None),
+                "url": getattr(work, "url", None),
+            }
+
+            return result
+
+        result = await loop.run_in_executor(None, do_get)
+
+        if result is None:
+            identifier = doi or openalex_id
+            return {
+                "success": False,
+                "error": f"Paper not found: {identifier}",
+                "identifier": identifier,
+            }
+
+        return {
+            "success": True,
+            "paper": result,
+            "source": "openalex_local",
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+async def openalex_count_handler(query: str) -> dict:
+    """Count papers matching a search query.
+
+    Args:
+        query: Search query string
+    """
+    try:
+        openalex = _ensure_openalex()
+        loop = asyncio.get_running_loop()
+
+        count = await loop.run_in_executor(None, openalex.count, query)
+
+        return {
+            "success": True,
+            "query": query,
+            "count": count,
+            "source": "openalex_local",
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+async def openalex_info_handler() -> dict:
+    """Get information about OpenAlex database configuration and status."""
+    try:
+        openalex = _ensure_openalex()
+        loop = asyncio.get_running_loop()
+
+        info = await loop.run_in_executor(None, openalex.info)
+
+        return {
+            "success": True,
+            "info": info,
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# EOF

scitex/scholar/_mcp/openalex_tool_schemas.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-29
+# File: src/scitex/scholar/_mcp/openalex_tool_schemas.py
+"""OpenAlex-Local tool schemas for MCP server.
+
+Provides access to 250M+ papers via openalex-local database.
+"""
+
+from __future__ import annotations
+
+import mcp.types as types
+
+__all__ = ["get_openalex_tool_schemas"]
+
+
+def get_openalex_tool_schemas() -> list[types.Tool]:
+    """Return OpenAlex-Local tool schemas."""
+    return [
+        types.Tool(
+            name="openalex_search",
+            description=(
+                "Search OpenAlex database (250M+ papers) via openalex-local. "
+                "Fast full-text search with year filtering. Includes citation data."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query string (full-text search)",
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of results",
+                        "default": 20,
+                    },
+                    "offset": {
+                        "type": "integer",
+                        "description": "Number of results to skip for pagination",
+                        "default": 0,
+                    },
+                    "year_min": {
+                        "type": "integer",
+                        "description": "Minimum publication year filter",
+                    },
+                    "year_max": {
+                        "type": "integer",
+                        "description": "Maximum publication year filter",
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        types.Tool(
+            name="openalex_get",
+            description="Get a paper by DOI or OpenAlex ID from OpenAlex database.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "doi": {
+                        "type": "string",
+                        "description": "DOI of the paper (e.g., '10.1038/nature12373')",
+                    },
+                    "openalex_id": {
+                        "type": "string",
+                        "description": "OpenAlex ID (e.g., 'W2100837269')",
+                    },
+                },
+            },
+        ),
+        types.Tool(
+            name="openalex_count",
+            description="Count papers matching a search query in OpenAlex database.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query string",
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        types.Tool(
+            name="openalex_info",
+            description="Get OpenAlex database configuration and status.",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
+    ]
+
+
+# EOF

scitex/scholar/_mcp/tool_schemas.py

@@ -3,9 +3,14 @@
 # File: src/scitex/scholar/_mcp.tool_schemas.py
 # ----------------------------------------
 """Tool schemas for the scitex-scholar MCP server."""
+
 from __future__ import annotations
+
 import mcp.types as types
+
 __all__ = ["get_tool_schemas"]
+
+
 def get_tool_schemas() -> list[types.Tool]:
     """Return all tool schemas for the Scholar MCP server."""
     base_schemas = [
@@ -500,6 +505,16 @@ def get_tool_schemas() -> list[types.Tool]:
             },
         ),
     ]
+    from .crossref_tool_schemas import get_crossref_tool_schemas
     from .job_tool_schemas import get_job_tool_schemas
-    return base_schemas + get_job_tool_schemas()
+    from .openalex_tool_schemas import get_openalex_tool_schemas
+
+    return (
+        base_schemas
+        + get_job_tool_schemas()
+        + get_crossref_tool_schemas()
+        + get_openalex_tool_schemas()
+    )
+
+
 # EOF

scitex/scholar/local_dbs/__init__.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-29
+# File: src/scitex/scholar/local_dbs/__init__.py
+"""Local database integrations for scitex.scholar.
+
+This package provides access to local scholarly databases:
+- crossref_scitex: CrossRef database (167M+ papers via crossref-local)
+- openalex_scitex: OpenAlex database (284M+ works via openalex-local)
+
+Both modules delegate directly to their respective external packages
+without any additional logic.
+
+Usage:
+    >>> from scitex.scholar.local_dbs import crossref_scitex
+    >>> results = crossref_scitex.search("machine learning")
+
+    >>> from scitex.scholar.local_dbs import openalex_scitex
+    >>> results = openalex_scitex.search("neural networks")
+"""
+
+from __future__ import annotations
+
+from . import crossref_scitex, openalex_scitex
+
+__all__ = [
+    "crossref_scitex",
+    "openalex_scitex",
+]
+
+
+# EOF

scitex/scholar/local_dbs/crossref_scitex.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-29
+# File: src/scitex/scholar/local_dbs/crossref_scitex.py
+"""CrossRef-SciTeX: Minimal API for crossref-local.
+
+Usage:
+    >>> from scitex.scholar.local_dbs import crossref_scitex
+    >>> results = crossref_scitex.search("machine learning")
+    >>> work = crossref_scitex.get("10.1038/nature12373")
+"""
+
+try:
+    from crossref_local import (
+        SearchResult,
+        # Classes
+        Work,
+        count,
+        get,
+        info,
+        # Core functions
+        search,
+    )
+except ImportError as e:
+    raise ImportError(
+        "crossref-local not installed. Install with: pip install crossref-local"
+    ) from e
+
+__all__ = ["search", "get", "count", "info", "Work", "SearchResult"]
+
+# EOF

scitex/scholar/local_dbs/openalex_scitex.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-29
+# File: src/scitex/scholar/local_dbs/openalex_scitex.py
+"""OpenAlex-SciTeX: Minimal API for openalex-local.
+
+Usage:
+    >>> from scitex.scholar.local_dbs import openalex_scitex
+    >>> results = openalex_scitex.search("machine learning")
+    >>> work = openalex_scitex.get("10.1038/nature12373")
+"""
+
+try:
+    from openalex_local import (
+        SearchResult,
+        # Classes
+        Work,
+        count,
+        get,
+        info,
+        # Core functions
+        search,
+    )
+except ImportError as e:
+    raise ImportError(
+        "openalex-local not installed. Install with: pip install openalex-local"
+    ) from e
+
+__all__ = ["search", "get", "count", "info", "Work", "SearchResult"]
+
+# EOF

scitex/scholar/mcp_server.py

@@ -3,8 +3,17 @@
 # File: src/scitex/scholar/mcp_server.py
 # ----------------------------------------
 
-"""
-MCP Server for SciTeX Scholar - Scientific Literature Management
+"""MCP Server for SciTeX Scholar - Scientific Literature Management.
+
+.. deprecated::
+    This standalone server is deprecated. Use the unified scitex MCP server instead:
+
+    CLI: scitex serve
+    Python: from scitex.mcp_server import run_server
+
+    The unified server includes all scholar tools plus other scitex tools.
+    Scholar tools are prefixed with 'scholar_' (e.g., scholar_search_papers).
+    Scholar resources are available at scholar://library and scholar://bibtex.
 
 Provides tools for:
 - Searching papers across multiple databases
@@ -16,6 +25,15 @@ Provides tools for:
 
 from __future__ import annotations
 
+import warnings
+
+warnings.warn(
+    "scitex.scholar.mcp_server is deprecated. Use 'scitex serve' or "
+    "'from scitex.mcp_server import run_server' for the unified MCP server.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
 import asyncio
 import os
 from datetime import datetime
@@ -67,11 +85,18 @@ class ScholarServer:
 
                 self._scholar_instance = Scholar()
             except ImportError as e:
-                raise RuntimeError(f"Scholar module not available: {e}")
+                raise RuntimeError(f"Scholar module not available: {e}") from e
         return self._scholar_instance
 
     def setup_handlers(self):
         """Set up MCP server handlers."""
+        from ._mcp.crossref_handlers import (
+            crossref_citations_handler,
+            crossref_count_handler,
+            crossref_get_handler,
+            crossref_info_handler,
+            crossref_search_handler,
+        )
         from ._mcp.handlers import (
             add_papers_to_project_handler,
             authenticate_handler,
@@ -186,6 +211,36 @@ class ScholarServer:
             elif name == "get_job_result":
                 return await self._wrap_result(get_job_result_handler(**arguments))
 
+            # CrossRef-Local Tools
+            elif name == "crossref_search":
+                return await self._wrap_result(crossref_search_handler(**arguments))
+            elif name == "crossref_get":
+                return await self._wrap_result(crossref_get_handler(**arguments))
+            elif name == "crossref_count":
+                return await self._wrap_result(crossref_count_handler(**arguments))
+            elif name == "crossref_citations":
+                return await self._wrap_result(crossref_citations_handler(**arguments))
+            elif name == "crossref_info":
+                return await self._wrap_result(crossref_info_handler(**arguments))
+
+            # OpenAlex-Local Tools
+            elif name == "openalex_search":
+                from ._mcp.openalex_handlers import openalex_search_handler
+
+                return await self._wrap_result(openalex_search_handler(**arguments))
+            elif name == "openalex_get":
+                from ._mcp.openalex_handlers import openalex_get_handler
+
+                return await self._wrap_result(openalex_get_handler(**arguments))
+            elif name == "openalex_count":
+                from ._mcp.openalex_handlers import openalex_count_handler
+
+                return await self._wrap_result(openalex_count_handler(**arguments))
+            elif name == "openalex_info":
+                from ._mcp.openalex_handlers import openalex_info_handler
+
+                return await self._wrap_result(openalex_info_handler(**arguments))
+
             else:
                 raise ValueError(f"Unknown tool: {name}")
 
@@ -340,7 +395,7 @@ async def _run_server():
 
 
 def main():
-    """Main entry point for the MCP server."""
+    """Run the MCP server."""
     if not MCP_AVAILABLE:
         import sys