scmcp-shared 0.3.7__py3-none-any.whl → 0.5.0__py3-none-any.whl

scmcp_shared/schema/tool.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel, Field
+from typing import List
+
+
+class Tool(BaseModel):
+    name: str = Field(description="The name of the tool")
+    description: str = Field(description="The description of the tool")
+
+
+class ToolList(BaseModel):
+    tools: List[Tool]

scmcp_shared/schema/util.py

@@ -1,99 +1,93 @@
+from pydantic import Field, BaseModel
+from typing import Optional, List, Dict, Any, Literal
 
-from pydantic import (
-    Field,
-    ValidationInfo,
-    computed_field,
-    field_validator,
-    model_validator,BaseModel
-)
-from typing import Optional, Union, List, Dict, Any, Callable, Collection, Literal
 
-
-
-class MarkVarParams(BaseModel):
+class MarkVarParam(BaseModel):
     """Determine or mark if each gene meets specific conditions and store results in adata.var as boolean values"""
-    
+
     var_name: str = Field(
         default=None,
-        description="Column name that will be added to adata.var, do not set if user does not ask"
+        description="Column name that will be added to adata.var, do not set if user does not ask",
     )
     pattern_type: Optional[Literal["startswith", "endswith", "contains"]] = Field(
         default=None,
-        description="Pattern matching type (startswith/endswith/contains), it should be None when gene_class is not None"
-    )    
+        description="Pattern matching type (startswith/endswith/contains), it should be None when gene_class is not None",
+    )
     patterns: Optional[str] = Field(
         default=None,
-        description="gene pattern to match, must be a string, it should be None when gene_class is not None"
+        description="gene pattern to match, must be a string, it should be None when gene_class is not None",
     )
-    
+
     gene_class: Optional[Literal["mitochondrion", "ribosomal", "hemoglobin"]] = Field(
-        default=None,
-        description="Gene class type (Mitochondrion/Ribosomal/Hemoglobin)"
+        default=None, description="Gene class type (Mitochondrion/Ribosomal/Hemoglobin)"
     )
 
 
-class ListVarParams(BaseModel):
-    """ListVarModel"""    
+class ListVarParam(BaseModel):
+    """ListVarModel"""
+
+    pass
+
+
+class ListObsParam(BaseModel):
+    """ListObsModel"""
+
     pass
 
-class ListObsParams(BaseModel):
-    """ListObsModel"""    
-    pass    
 
-class VarNamesParams(BaseModel):
-    """ListObsModel"""    
-    var_names: List[str] = Field(
-            default=None,
-            description="gene names."
-        )
+class VarNamesParam(BaseModel):
+    """ListObsModel"""
+
+    var_names: List[str] = Field(default=None, description="gene names.")
 
 
-class ConcatBaseParams(BaseModel):
+class ConcatBaseParam(BaseModel):
     """Model for concatenating AnnData objects"""
-    
-    axis: Literal['obs', 0, 'var', 1] = Field(
-        default='obs',
-        description="Which axis to concatenate along. 'obs' or 0 for observations, 'var' or 1 for variables."
+
+    axis: Literal["obs", 0, "var", 1] = Field(
+        default="obs",
+        description="Which axis to concatenate along. 'obs' or 0 for observations, 'var' or 1 for variables.",
     )
-    join: Literal['inner', 'outer'] = Field(
-        default='inner',
-        description="How to align values when concatenating. If 'outer', the union of the other axis is taken. If 'inner', the intersection."
+    join: Literal["inner", "outer"] = Field(
+        default="inner",
+        description="How to align values when concatenating. If 'outer', the union of the other axis is taken. If 'inner', the intersection.",
     )
-    merge: Optional[Literal['same', 'unique', 'first', 'only']] = Field(
+    merge: Optional[Literal["same", "unique", "first", "only"]] = Field(
         default=None,
-        description="How elements not aligned to the axis being concatenated along are selected."
+        description="How elements not aligned to the axis being concatenated along are selected.",
     )
-    uns_merge: Optional[Literal['same', 'unique', 'first', 'only']] = Field(
+    uns_merge: Optional[Literal["same", "unique", "first", "only"]] = Field(
         default=None,
-        description="How the elements of .uns are selected. Uses the same set of strategies as the merge argument, except applied recursively."
+        description="How the elements of .uns are selected. Uses the same set of strategies as the merge argument, except applied recursively.",
     )
     label: Optional[str] = Field(
         default=None,
-        description="label different adata, Column in axis annotation (i.e. .obs or .var) to place batch information in. "
+        description="label different adata, Column in axis annotation (i.e. .obs or .var) to place batch information in. ",
     )
     keys: Optional[List[str]] = Field(
         default=None,
-        description="Names for each object being added. These values are used for column values for label or appended to the index if index_unique is not None."
+        description="Names for each object being added. These values are used for column values for label or appended to the index if index_unique is not None.",
     )
     index_unique: Optional[str] = Field(
         default=None,
-        description="Whether to make the index unique by using the keys. If provided, this is the delimiter between '{orig_idx}{index_unique}{key}'."
+        description="Whether to make the index unique by using the keys. If provided, this is the delimiter between '{orig_idx}{index_unique}{key}'.",
     )
     fill_value: Optional[Any] = Field(
         default=None,
-        description="When join='outer', this is the value that will be used to fill the introduced indices."
+        description="When join='outer', this is the value that will be used to fill the introduced indices.",
     )
     pairwise: bool = Field(
         default=False,
-        description="Whether pairwise elements along the concatenated dimension should be included."
+        description="Whether pairwise elements along the concatenated dimension should be included.",
     )
 
 
-class DPTIROOTParams(BaseModel):
+class DPTIROOTParam(BaseModel):
     """Input schema for setting the root cell for diffusion pseudotime."""
+
     diffmap_key: str = Field(
         default="X_diffmap",
-        description="Key for diffusion map coordinates stored in adata.obsm."
+        description="Key for diffusion map coordinates stored in adata.obsm.",
     )
     dimension: int = Field(
         description="Dimension index to use for finding the root cell."
@@ -103,36 +97,27 @@ class DPTIROOTParams(BaseModel):
     )
 
 
-class CelltypeMapCellTypeParams(BaseModel):
+class CelltypeMapCellTypeParam(BaseModel):
     """Input schema for mapping cluster IDs to cell type names."""
-    cluster_key: str = Field(
-        description="Key in adata.obs containing cluster IDs."
-    )
-    added_key: str = Field(
-        description="Key to add to adata.obs for cell type names."
-    )
+
+    cluster_key: str = Field(description="Key in adata.obs containing cluster IDs.")
+    added_key: str = Field(description="Key to add to adata.obs for cell type names.")
     mapping: Dict[str, str] = Field(
         default=None,
-        description="Mapping Dictionary from cluster IDs to cell type names."
+        description="Mapping Dictionary from cluster IDs to cell type names.",
     )
     new_names: Optional[List[str]] = Field(
-        default=None,
-        description="a list of new cell type names."
+        default=None, description="a list of new cell type names."
     )
-    
 
 
-class AddLayerParams(BaseModel):
+class AddLayerParam(BaseModel):
     """Input schema for adding a layer to AnnData object."""
-    layer_name: str = Field(
-        description="Name of the layer to add to adata.layers."
-    )
- 
 
-class QueryOpLogParams(BaseModel):
-    """QueryOpLogModel"""    
-    n: int = Field(
-        default=10,
-        description="Number of operations to return."
-    )
-    
+    layer_name: str = Field(description="Name of the layer to add to adata.layers.")
+
+
+class QueryOpLogParam(BaseModel):
+    """QueryOpLogModel"""
+
+    n: int = Field(default=10, description="Number of operations to return.")

scmcp_shared/server/__init__.py

@@ -1,13 +1 @@
 from __future__ import annotations
-
-from collections.abc import Iterable, AsyncIterator
-from typing import Any, Dict, List, Optional
-from contextlib import asynccontextmanager
-import asyncio
-
-from .base import BaseMCP,AdataState,BaseMCPManager
-from .io import ScanpyIOMCP, io_mcp
-from .util import ScanpyUtilMCP
-from .pl import ScanpyPlottingMCP
-from .pp import ScanpyPreprocessingMCP
-from .tl import ScanpyToolsMCP

scmcp_shared/server/auto.py

@@ -0,0 +1,54 @@
+from fastmcp import FastMCP
+from fastmcp.server.dependencies import get_context
+from ..agent import select_tool
+from pydantic import Field
+
+auto_mcp = FastMCP("SmartMCP-select-Server")
+
+
+@auto_mcp.tool(tags={"auto"})
+def search_tool(
+    task: str = Field(
+        description="The tasks or questions that needs to be solved using available tools"
+    ),
+):
+    """search the tools and get tool parameters that can be used to solve the  user's tasks or questions"""
+    ctx = get_context()
+    fastmcp = ctx.fastmcp
+    all_tools = fastmcp._tool_manager._all_tools
+    auto_tools = fastmcp._tool_manager._tools
+    fastmcp._tool_manager._tools = all_tools
+    query = f"<task>{task}</task>\n"
+    for name in all_tools:
+        tool = all_tools[name]
+        query += f"<Tool>\n<name>{name}</name>\n<description>{tool.description}</description>\n</Tool>\n"
+
+    results = select_tool(query)
+    tool_list = []
+    for tool in results:
+        tool = tool.model_dump()
+        tool["parameters"] = all_tools[tool["name"]].parameters
+        tool_list.append(tool)
+    fastmcp._tool_manager._tools = auto_tools
+    return tool_list
+
+
+@auto_mcp.tool(tags={"auto"})
+async def run_tool(
+    name: str = Field(description="The name of the tool to run"),
+    parameter: dict = Field(description="The parameters to pass to the tool"),
+):
+    """run the tool with the given name and parameters. Only start call the tool when last tool is finished."""
+    ctx = get_context()
+    fastmcp = ctx.fastmcp
+    all_tools = fastmcp._tool_manager._all_tools
+    auto_tools = fastmcp._tool_manager._tools
+    fastmcp._tool_manager._tools = all_tools
+
+    try:
+        result = await fastmcp._tool_manager.call_tool(name, parameter)
+    except Exception as e:
+        fastmcp._tool_manager._tools = auto_tools
+        result = {"error": str(e)}
+
+    return result

scmcp_shared/server/code.py

@@ -0,0 +1,3 @@
+from abcoder.server import nb_mcp
+
+__all__ = ["nb_mcp"]

scmcp_shared/server/preset/__init__.py

@@ -0,0 +1,14 @@
+from .io import ScanpyIOMCP, io_mcp
+from .pl import ScanpyPlottingMCP
+from .pp import ScanpyPreprocessingMCP
+from .tl import ScanpyToolsMCP
+from .util import ScanpyUtilMCP
+
+__all__ = [
+    "io_mcp",
+    "ScanpyIOMCP",
+    "ScanpyPlottingMCP",
+    "ScanpyPreprocessingMCP",
+    "ScanpyToolsMCP",
+    "ScanpyUtilMCP",
+]

scmcp_shared/server/{io.py → preset/io.py}

@@ -1,23 +1,25 @@
-import os
-import inspect
 from pathlib import Path
 import scanpy as sc
-from fastmcp import FastMCP, Context
 from fastmcp.tools.tool import Tool
 from fastmcp.exceptions import ToolError
-from ..schema import AdataInfo
-from ..schema.io import *
-from ..util import filter_args, forward_request, get_ads, generate_msg
-from .base import BaseMCP
+from scmcp_shared.schema.preset import AdataInfo
+from scmcp_shared.schema.preset.io import *
+from scmcp_shared.util import filter_args, forward_request, get_ads
+from scmcp_shared.mcp_base import BaseMCP
 
 
 class ScanpyIOMCP(BaseMCP):
-    def __init__(self, include_tools: list = None, exclude_tools: list = None, AdataInfo = AdataInfo):
+    def __init__(
+        self,
+        include_tools: list = None,
+        exclude_tools: list = None,
+        AdataInfo=AdataInfo,
+    ):
         """Initialize ScanpyIOMCP with optional tool filtering."""
         super().__init__("SCMCP-IO-Server", include_tools, exclude_tools, AdataInfo)
 
     def _tool_read(self):
-        def _read(request: ReadParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _read(request: ReadParam, adinfo: self.AdataInfo = self.AdataInfo()):
             """
             Read data from 10X directory or various file formats (h5ad, 10x, text files, etc.).
             """
@@ -34,7 +36,7 @@ class ScanpyIOMCP(BaseMCP):
                 elif file.is_file():
                     func_kwargs = filter_args(request, sc.read)
                     adata = sc.read(**func_kwargs)
-                    if not kwargs.get("transpose", True):
+                    if kwargs.get("transpose", False):
                         adata = adata.T
                 else:
                     raise FileNotFoundError(f"{kwargs['filename']} does not exist")
@@ -44,7 +46,7 @@ class ScanpyIOMCP(BaseMCP):
                     ads.active_id = adinfo.sampleid
                 else:
                     ads.active_id = f"adata{len(ads.adata_dic[adinfo.adtype])}"
-                    
+
                 adata.layers["counts"] = adata.X
                 adata.var_names_make_unique()
                 adata.obs_names_make_unique()
@@ -52,30 +54,31 @@ class ScanpyIOMCP(BaseMCP):
                 ads.set_adata(adata, adinfo=adinfo)
                 return [
                     {
-                        "sampleid": adinfo.sampleid or ads.active_id, 
-                        "adtype": adinfo.adtype, 
+                        "sampleid": adinfo.sampleid or ads.active_id,
+                        "adtype": adinfo.adtype,
                         "adata": adata,
                         "adata.obs_names[:10]": adata.obs_names[:10],
                         "adata.var_names[:10]": adata.var_names[:10],
-                        "notice": "check obs_names and var_names. transpose the data if needed"
+                        "notice": "check obs_names and var_names. transpose the data if needed",
                     }
-                    ]
+                ]
             except ToolError as e:
                 raise ToolError(e)
             except Exception as e:
-                if hasattr(e, '__context__') and e.__context__:
+                if hasattr(e, "__context__") and e.__context__:
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return Tool.from_function(_read, name="read")
+
+        return Tool.from_function(_read, name="read", enabled=True)
 
     def _tool_write(self):
-        def _write(request: WriteParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _write(request: WriteParam, adinfo: self.AdataInfo = self.AdataInfo()):
             """save adata into a file."""
             try:
                 res = forward_request("io_write", request, adinfo)
                 if res is not None:
-                    return res   
+                    return res
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
                 kwargs = request.model_dump()
@@ -84,12 +87,13 @@ class ScanpyIOMCP(BaseMCP):
             except ToolError as e:
                 raise ToolError(e)
             except Exception as e:
-                if hasattr(e, '__context__') and e.__context__:
+                if hasattr(e, "__context__") and e.__context__:
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return Tool.from_function(_write, name="write")
+
+        return Tool.from_function(_write, name="write", enabled=True)
 
 
 # Create an instance of the class
-io_mcp = ScanpyIOMCP().mcp
+io_mcp = ScanpyIOMCP().mcp