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

scitex/_mcp_resources/__init__.py

@@ -20,6 +20,7 @@ from ._cheatsheet import register_cheatsheet_resources
 from ._figrecipe import register_figrecipe_resources
 from ._formats import register_format_resources
 from ._modules import register_module_resources
+from ._scholar import register_scholar_resources
 from ._session import register_session_resources
 
 __all__ = ["register_resources"]
@@ -32,6 +33,7 @@ def register_resources(mcp) -> None:
     register_module_resources(mcp)
     register_format_resources(mcp)
     register_figrecipe_resources(mcp)
+    register_scholar_resources(mcp)
 
 
 # EOF

scitex/_mcp_resources/_scholar.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-29
+# File: src/scitex/_mcp_resources/_scholar.py
+"""Scholar library resources for FastMCP unified server.
+
+Provides dynamic resources for:
+- scholar://library/{project} - Project paper listings
+- scholar://bibtex/{filename} - BibTeX file contents
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+
+__all__ = ["register_scholar_resources"]
+
+# Directory configuration
+SCITEX_BASE_DIR = Path(os.getenv("SCITEX_DIR", Path.home() / ".scitex"))
+SCITEX_SCHOLAR_DIR = SCITEX_BASE_DIR / "scholar"
+
+
+def _get_scholar_dir() -> Path:
+    """Get the scholar data directory."""
+    SCITEX_SCHOLAR_DIR.mkdir(parents=True, exist_ok=True)
+    return SCITEX_SCHOLAR_DIR
+
+
+def register_scholar_resources(mcp) -> None:
+    """Register scholar library resources with FastMCP server."""
+
+    @mcp.resource("scholar://library")
+    def list_library_projects() -> str:
+        """List all scholar library projects with paper counts."""
+        scholar_dir = _get_scholar_dir()
+        library_dir = scholar_dir / "library"
+
+        if not library_dir.exists():
+            return json.dumps({"projects": [], "total": 0}, indent=2)
+
+        projects = []
+        for project_dir in library_dir.iterdir():
+            if project_dir.is_dir() and not project_dir.name.startswith("."):
+                pdf_count = len(list(project_dir.rglob("*.pdf")))
+                metadata_count = len(list(project_dir.rglob("metadata.json")))
+                projects.append(
+                    {
+                        "name": project_dir.name,
+                        "pdf_count": pdf_count,
+                        "paper_count": metadata_count,
+                        "uri": f"scholar://library/{project_dir.name}",
+                    }
+                )
+
+        return json.dumps(
+            {
+                "projects": projects,
+                "total": len(projects),
+                "library_path": str(library_dir),
+            },
+            indent=2,
+        )
+
+    @mcp.resource("scholar://library/{project}")
+    def get_library_project(project: str) -> str:
+        """Get papers in a specific library project."""
+        library_dir = _get_scholar_dir() / "library" / project
+
+        if not library_dir.exists():
+            return json.dumps({"error": f"Project not found: {project}"}, indent=2)
+
+        metadata_files = list(library_dir.rglob("metadata.json"))
+        papers = []
+
+        for meta_file in metadata_files[:100]:
+            try:
+                with open(meta_file) as f:
+                    meta = json.load(f)
+                pdf_exists = any(meta_file.parent.glob("*.pdf"))
+                papers.append(
+                    {
+                        "id": meta_file.parent.name,
+                        "title": meta.get("title"),
+                        "doi": meta.get("doi"),
+                        "authors": meta.get("authors", [])[:3],
+                        "year": meta.get("year"),
+                        "has_pdf": pdf_exists,
+                    }
+                )
+            except Exception:
+                pass
+
+        return json.dumps(
+            {
+                "project": project,
+                "paper_count": len(papers),
+                "papers": papers,
+            },
+            indent=2,
+        )
+
+    @mcp.resource("scholar://bibtex")
+    def list_bibtex_files() -> str:
+        """List recent BibTeX files in scholar directory."""
+        scholar_dir = _get_scholar_dir()
+        bib_files = []
+
+        for bib_file in sorted(
+            scholar_dir.rglob("*.bib"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )[:20]:
+            mtime = datetime.fromtimestamp(bib_file.stat().st_mtime)
+            bib_files.append(
+                {
+                    "name": bib_file.name,
+                    "path": str(bib_file),
+                    "modified": mtime.isoformat(),
+                    "uri": f"scholar://bibtex/{bib_file.name}",
+                }
+            )
+
+        return json.dumps(
+            {
+                "bibtex_files": bib_files,
+                "total": len(bib_files),
+            },
+            indent=2,
+        )
+
+    @mcp.resource("scholar://bibtex/{filename}")
+    def get_bibtex_file(filename: str) -> str:
+        """Read a BibTeX file by name."""
+        scholar_dir = _get_scholar_dir()
+        bib_files = list(scholar_dir.rglob(filename))
+
+        if not bib_files:
+            return json.dumps({"error": f"BibTeX file not found: {filename}"}, indent=2)
+
+        with open(bib_files[0]) as f:
+            content = f.read()
+
+        return content
+
+
+# EOF

scitex/_mcp_tools/__init__.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 from .audio import register_audio_tools
 from .canvas import register_canvas_tools
 from .capture import register_capture_tools
+from .dataset import register_dataset_tools
 from .diagram import register_diagram_tools
 from .introspect import register_introspect_tools
 from .plt import register_plt_tools
@@ -26,6 +27,7 @@ def register_all_tools(mcp) -> None:
     register_audio_tools(mcp)
     register_canvas_tools(mcp)
     register_capture_tools(mcp)
+    register_dataset_tools(mcp)
     register_diagram_tools(mcp)
     register_introspect_tools(mcp)
     register_plt_tools(mcp)

scitex/_mcp_tools/canvas.py

@@ -1,12 +1,20 @@
 #!/usr/bin/env python3
-# Timestamp: 2026-01-15
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/_mcp_tools/canvas.py
-"""Canvas module tools for FastMCP unified server."""
+# Timestamp: 2026-01-29
+# File: src/scitex/_mcp_tools/canvas.py
+"""Canvas module tools for FastMCP unified server.
+
+.. deprecated:: 2.16.0
+    Canvas tools are deprecated. Use figrecipe MCP tools instead:
+    - plt_compose for multi-panel composition
+    - plt_plot for creating figures
+    - plt_reproduce for reproducing from recipes
+
+    figrecipe is mounted automatically if installed.
+"""
 
 from __future__ import annotations
 
 import json
-from typing import Optional
 
 
 def _json(data: dict) -> str:
@@ -14,8 +22,14 @@ def _json(data: dict) -> str:
 
 
 def register_canvas_tools(mcp) -> None:
-    """Register canvas tools with FastMCP server."""
+    """Register canvas tools with FastMCP server.
+
+    Note: These tools are deprecated. Use plt_compose from figrecipe instead.
+    plt_* and diagram_* tools are registered via plt.py and diagram.py respectively.
+    """
 
+    # Legacy canvas tools only (deprecated, for backward compatibility)
+    # plt_* tools are registered in plt.py, diagram_* in diagram.py
     @mcp.tool()
     async def canvas_create_canvas(
         parent_dir: str,
@@ -23,7 +37,7 @@ def register_canvas_tools(mcp) -> None:
         width_mm: float = 180,
         height_mm: float = 120,
     ) -> str:
-        """[canvas] Create a new paper figure canvas workspace."""
+        """[canvas][DEPRECATED] Create a canvas workspace. Use plt_compose instead."""
         from scitex.canvas._mcp.handlers import create_canvas_handler
 
         result = await create_canvas_handler(
@@ -32,6 +46,7 @@ def register_canvas_tools(mcp) -> None:
             width_mm=width_mm,
             height_mm=height_mm,
         )
+        result["_deprecated"] = "Use plt_compose from figrecipe instead"
         return _json(result)
 
     @mcp.tool()
@@ -44,9 +59,9 @@ def register_canvas_tools(mcp) -> None:
         y_mm: float = 0,
         width_mm: float = 50,
         height_mm: float = 50,
-        label: Optional[str] = None,
+        label: str | None = None,
     ) -> str:
-        """[canvas] Add a panel to an existing canvas from an image or plot."""
+        """[canvas][DEPRECATED] Add a panel to canvas. Use plt_compose instead."""
         from scitex.canvas._mcp.handlers import add_panel_handler
 
         result = await add_panel_handler(
@@ -60,23 +75,25 @@ def register_canvas_tools(mcp) -> None:
             height_mm=height_mm,
             label=label,
         )
+        result["_deprecated"] = "Use plt_compose from figrecipe instead"
         return _json(result)
 
     @mcp.tool()
     async def canvas_list_panels(parent_dir: str, canvas_name: str) -> str:
-        """[canvas] List all panels in a canvas with their properties."""
+        """[canvas][DEPRECATED] List panels in a canvas."""
         from scitex.canvas._mcp.handlers import list_panels_handler
 
         result = await list_panels_handler(
             parent_dir=parent_dir, canvas_name=canvas_name
         )
+        result["_deprecated"] = "Use figrecipe instead"
         return _json(result)
 
     @mcp.tool()
     async def canvas_remove_panel(
         parent_dir: str, canvas_name: str, panel_name: str
     ) -> str:
-        """[canvas] Remove a panel from a canvas."""
+        """[canvas][DEPRECATED] Remove a panel from canvas."""
         from scitex.canvas._mcp.handlers import remove_panel_handler
 
         result = await remove_panel_handler(
@@ -84,17 +101,18 @@ def register_canvas_tools(mcp) -> None:
             canvas_name=canvas_name,
             panel_name=panel_name,
         )
+        result["_deprecated"] = "Use figrecipe instead"
         return _json(result)
 
     @mcp.tool()
     async def canvas_export_canvas(
         parent_dir: str,
         canvas_name: str,
-        output_path: Optional[str] = None,
-        format: Optional[str] = None,
+        output_path: str | None = None,
+        format: str | None = None,
         dpi: int = 300,
     ) -> str:
-        """[canvas] Export/render canvas to PNG, PDF, or SVG format."""
+        """[canvas][DEPRECATED] Export canvas to image. Use plt_compose instead."""
         from scitex.canvas._mcp.handlers import export_canvas_handler
 
         result = await export_canvas_handler(
@@ -104,24 +122,27 @@ def register_canvas_tools(mcp) -> None:
             format=format,
             dpi=dpi,
         )
+        result["_deprecated"] = "Use plt_compose from figrecipe instead"
         return _json(result)
 
     @mcp.tool()
     async def canvas_list_canvases(parent_dir: str) -> str:
-        """[canvas] List all canvases in a directory."""
+        """[canvas][DEPRECATED] List canvases in a directory."""
         from scitex.canvas._mcp.handlers import list_canvases_handler
 
         result = await list_canvases_handler(parent_dir=parent_dir)
+        result["_deprecated"] = "Use figrecipe instead"
         return _json(result)
 
     @mcp.tool()
     async def canvas_canvas_exists(parent_dir: str, canvas_name: str) -> str:
-        """[canvas] Check if a canvas exists."""
+        """[canvas][DEPRECATED] Check if a canvas exists."""
         from scitex.canvas._mcp.handlers import canvas_exists_handler
 
         result = await canvas_exists_handler(
             parent_dir=parent_dir, canvas_name=canvas_name
         )
+        result["_deprecated"] = "Use figrecipe instead"
         return _json(result)
 
 

scitex/_mcp_tools/dataset.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""Dataset module tools - thin wrapper delegating to scitex-dataset package.
+
+Single source of truth: scitex-dataset MCP tools.
+"""
+
+from __future__ import annotations
+
+
+def register_dataset_tools(mcp) -> None:
+    """Register dataset tools by delegating to scitex-dataset package."""
+    try:
+        from scitex_dataset._mcp.tools import register_all_tools
+
+        # Delegate all MCP tools to scitex-dataset
+        register_all_tools(mcp)
+    except ImportError:
+        # Fallback when scitex-dataset is not installed
+        @mcp.tool()
+        def dataset_usage() -> str:
+            """[dataset] Get usage guide for SciTeX Dataset (not installed)."""
+            return (
+                "scitex-dataset is required. Install with: pip install scitex-dataset"
+            )
+
+
+# EOF

scitex/_mcp_tools/plt.py

@@ -28,15 +28,16 @@ def register_plt_tools(mcp) -> None:
         from figrecipe._mcp import server as fr_mcp
 
         # Access underlying functions from FunctionTool objects
-        _plot = fr_mcp.plot.fn
-        _reproduce = fr_mcp.reproduce.fn
-        _compose = fr_mcp.compose.fn
-        _info = fr_mcp.info.fn
-        _validate = fr_mcp.validate.fn
-        _crop = fr_mcp.crop.fn
-        _extract_data = fr_mcp.extract_data.fn
-        _list_styles = fr_mcp.list_styles.fn
-        _get_plot_types = fr_mcp.get_plot_types.fn
+        # figrecipe tools are named plt_* for proper MCP categorization
+        _plot = fr_mcp.plt_plot.fn
+        _reproduce = fr_mcp.plt_reproduce.fn
+        _compose = fr_mcp.plt_compose.fn
+        _info = fr_mcp.plt_info.fn
+        _validate = fr_mcp.plt_validate.fn
+        _crop = fr_mcp.plt_crop.fn
+        _extract_data = fr_mcp.plt_extract_data.fn
+        _list_styles = fr_mcp.plt_list_styles.fn
+        _get_plot_types = fr_mcp.plt_get_plot_types.fn
 
         _FIGRECIPE_AVAILABLE = True
     except ImportError:
@@ -54,7 +55,6 @@ def register_plt_tools(mcp) -> None:
     # Delegate to figrecipe's MCP tools with plt_ prefix
     # Each wrapper simply calls the figrecipe function
 
-
     @mcp.tool()
     def plt_plot(
         spec: Dict[str, Any],

scitex/_mcp_tools/scholar.py

@@ -6,7 +6,6 @@
 from __future__ import annotations
 
 import json
-from typing import List, Optional
 
 
 def _json(data: dict) -> str:
@@ -20,10 +19,10 @@ def register_scholar_tools(mcp) -> None:
     async def scholar_search_papers(
         query: str,
         limit: int = 20,
-        year_min: Optional[int] = None,
-        year_max: Optional[int] = None,
+        year_min: int | None = None,
+        year_max: int | None = None,
         search_mode: str = "local",
-        sources: Optional[List[str]] = None,
+        sources: list[str] | None = None,
     ) -> str:
         """[scholar] Search for scientific papers. Supports local library search and external databases (CrossRef, Semantic Scholar, PubMed, arXiv, OpenAlex)."""
         from scitex.scholar._mcp.handlers import search_papers_handler
@@ -40,9 +39,9 @@ def register_scholar_tools(mcp) -> None:
 
     @mcp.tool()
     async def scholar_resolve_dois(
-        titles: Optional[List[str]] = None,
-        bibtex_path: Optional[str] = None,
-        project: Optional[str] = None,
+        titles: list[str] | None = None,
+        bibtex_path: str | None = None,
+        project: str | None = None,
         resume: bool = True,
     ) -> str:
         """[scholar] Resolve DOIs from paper titles using Crossref API. Supports resumable operation for large batches."""
@@ -59,7 +58,7 @@ def register_scholar_tools(mcp) -> None:
     @mcp.tool()
     async def scholar_enrich_bibtex(
         bibtex_path: str,
-        output_path: Optional[str] = None,
+        output_path: str | None = None,
         add_abstracts: bool = True,
         add_citations: bool = True,
         add_impact_factors: bool = True,
@@ -94,10 +93,10 @@ def register_scholar_tools(mcp) -> None:
 
     @mcp.tool()
     async def scholar_download_pdfs_batch(
-        dois: Optional[List[str]] = None,
-        bibtex_path: Optional[str] = None,
-        project: Optional[str] = None,
-        output_dir: Optional[str] = None,
+        dois: list[str] | None = None,
+        bibtex_path: str | None = None,
+        project: str | None = None,
+        output_dir: str | None = None,
         max_concurrent: int = 3,
         resume: bool = True,
     ) -> str:
@@ -116,7 +115,7 @@ def register_scholar_tools(mcp) -> None:
 
     @mcp.tool()
     async def scholar_get_library_status(
-        project: Optional[str] = None,
+        project: str | None = None,
         include_details: bool = False,
     ) -> str:
         """[scholar] Get status of the paper library: download progress, missing PDFs, validation status."""
@@ -138,8 +137,8 @@ def register_scholar_tools(mcp) -> None:
 
     @mcp.tool()
     async def scholar_validate_pdfs(
-        project: Optional[str] = None,
-        pdf_paths: Optional[List[str]] = None,
+        project: str | None = None,
+        pdf_paths: list[str] | None = None,
     ) -> str:
         """[scholar] Validate PDF files in library for completeness and readability."""
         from scitex.scholar._mcp.handlers import validate_pdfs_handler
@@ -152,8 +151,8 @@ def register_scholar_tools(mcp) -> None:
 
     @mcp.tool()
     async def scholar_resolve_openurls(
-        dois: List[str],
-        resolver_url: Optional[str] = None,
+        dois: list[str],
+        resolver_url: str | None = None,
         resume: bool = True,
     ) -> str:
         """[scholar] Resolve publisher URLs via OpenURL resolver for institutional access."""
@@ -169,7 +168,7 @@ def register_scholar_tools(mcp) -> None:
     @mcp.tool()
     async def scholar_authenticate(
         method: str,
-        institution: Optional[str] = None,
+        institution: str | None = None,
         force: bool = False,
         confirm: bool = False,
     ) -> str:
@@ -215,7 +214,7 @@ def register_scholar_tools(mcp) -> None:
     @mcp.tool()
     async def scholar_export_papers(
         output_path: str,
-        project: Optional[str] = None,
+        project: str | None = None,
         format: str = "bibtex",
         filter_has_pdf: bool = False,
     ) -> str:
@@ -233,7 +232,7 @@ def register_scholar_tools(mcp) -> None:
     @mcp.tool()
     async def scholar_create_project(
         project_name: str,
-        description: Optional[str] = None,
+        description: str | None = None,
     ) -> str:
         """[scholar] Create a new scholar project for organizing papers."""
         from scitex.scholar._mcp.handlers import create_project_handler
@@ -255,8 +254,8 @@ def register_scholar_tools(mcp) -> None:
     @mcp.tool()
     async def scholar_add_papers_to_project(
         project: str,
-        dois: Optional[List[str]] = None,
-        bibtex_path: Optional[str] = None,
+        dois: list[str] | None = None,
+        bibtex_path: str | None = None,
     ) -> str:
         """[scholar] Add papers to a project by DOI or from BibTeX file."""
         from scitex.scholar._mcp.handlers import add_papers_to_project_handler
@@ -270,14 +269,14 @@ def register_scholar_tools(mcp) -> None:
 
     @mcp.tool()
     async def scholar_parse_pdf_content(
-        pdf_path: Optional[str] = None,
-        doi: Optional[str] = None,
-        project: Optional[str] = None,
+        pdf_path: str | None = None,
+        doi: str | None = None,
+        project: str | None = None,
         mode: str = "scientific",
         extract_sections: bool = True,
         extract_tables: bool = False,
         extract_images: bool = False,
-        max_pages: Optional[int] = None,
+        max_pages: int | None = None,
     ) -> str:
         """[scholar] Parse PDF content to extract text, sections (IMRaD), tables, images, and metadata."""
         from scitex.scholar._mcp.handlers import parse_pdf_content_handler
@@ -297,14 +296,14 @@ def register_scholar_tools(mcp) -> None:
     # Job management tools (from job_handlers.py)
     @mcp.tool()
     async def scholar_fetch_papers(
-        papers: Optional[List[str]] = None,
-        bibtex_path: Optional[str] = None,
-        project: Optional[str] = None,
-        workers: Optional[int] = None,
+        papers: list[str] | None = None,
+        bibtex_path: str | None = None,
+        project: str | None = None,
+        workers: int | None = None,
         browser_mode: str = "stealth",
         chrome_profile: str = "system",
         force: bool = False,
-        output: Optional[str] = None,
+        output: str | None = None,
         async_mode: bool = True,
     ) -> str:
         """[scholar] Fetch papers to your library. Supports async mode (default) which returns immediately with a job_id for tracking."""
@@ -325,7 +324,7 @@ def register_scholar_tools(mcp) -> None:
 
     @mcp.tool()
     async def scholar_list_jobs(
-        status: Optional[str] = None,
+        status: str | None = None,
         limit: int = 20,
     ) -> str:
         """[scholar] List all background jobs with their status."""
@@ -369,79 +368,31 @@ def register_scholar_tools(mcp) -> None:
         result = await get_job_result_handler(job_id=job_id)
         return _json(result)
 
-    # =========================================================================
-    # CrossRef Tools (via crossref-local delegation - 167M+ papers)
-    # =========================================================================
+    # Import crossref-local and openalex-local MCP servers
+    _import_local_db_servers(mcp)
 
-    @mcp.tool()
-    async def scholar_crossref_search(
-        query: str,
-        limit: int = 20,
-        offset: int = 0,
-        year_min: Optional[int] = None,
-        year_max: Optional[int] = None,
-        enrich: bool = False,
-    ) -> str:
-        """[scholar] Search CrossRef database (167M+ papers) via crossref-local. Fast full-text search with optional citation enrichment."""
-        from scitex.scholar._mcp.crossref_handlers import crossref_search_handler
 
-        result = await crossref_search_handler(
-            query=query,
-            limit=limit,
-            offset=offset,
-            year_min=year_min,
-            year_max=year_max,
-            enrich=enrich,
-        )
-        return _json(result)
+def _import_local_db_servers(mcp) -> None:
+    """Mount crossref-local and openalex-local MCP servers if available.
 
-    @mcp.tool()
-    async def scholar_crossref_get(
-        doi: str,
-        include_citations: bool = False,
-        include_references: bool = False,
-    ) -> str:
-        """[scholar] Get paper metadata by DOI from CrossRef database."""
-        from scitex.scholar._mcp.crossref_handlers import crossref_get_handler
+    Uses fastmcp's mount() for automatic tool delegation.
+    Tools are prefixed: crossref_search, openalex_search, etc.
+    """
+    # Mount crossref-local MCP server (167M+ papers)
+    try:
+        from crossref_local.mcp_server import mcp as crossref_mcp
 
-        result = await crossref_get_handler(
-            doi=doi,
-            include_citations=include_citations,
-            include_references=include_references,
-        )
-        return _json(result)
+        mcp.mount(crossref_mcp, prefix="crossref")
+    except ImportError:
+        pass  # crossref-local not installed
 
-    @mcp.tool()
-    async def scholar_crossref_count(query: str) -> str:
-        """[scholar] Count papers matching a query in CrossRef database."""
-        from scitex.scholar._mcp.crossref_handlers import crossref_count_handler
-
-        result = await crossref_count_handler(query=query)
-        return _json(result)
-
-    @mcp.tool()
-    async def scholar_crossref_citations(
-        doi: str,
-        direction: str = "citing",
-        limit: int = 100,
-    ) -> str:
-        """[scholar] Get citation relationships (citing/cited papers) for a DOI."""
-        from scitex.scholar._mcp.crossref_handlers import crossref_citations_handler
+    # Mount openalex-local MCP server (250M+ papers)
+    try:
+        from openalex_local._cli.mcp_server import mcp as openalex_mcp
 
-        result = await crossref_citations_handler(
-            doi=doi,
-            direction=direction,
-            limit=limit,
-        )
-        return _json(result)
-
-    @mcp.tool()
-    async def scholar_crossref_info() -> str:
-        """[scholar] Get CrossRef database configuration and status info."""
-        from scitex.scholar._mcp.crossref_handlers import crossref_info_handler
-
-        result = await crossref_info_handler()
-        return _json(result)
+        mcp.mount(openalex_mcp, prefix="openalex")
+    except ImportError:
+        pass  # openalex-local not installed
 
 
 # EOF