scmcp-shared 0.3.6__py3-none-any.whl → 0.4.0__py3-none-any.whl

scmcp_shared/server/auto.py

@@ -0,0 +1,52 @@
+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()
+def search_tool(
+    task: str= Field(description="The tasks or questions that needs to be solved using available tools")
+):
+    """search the tools 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()
+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/base.py

@@ -6,7 +6,7 @@ from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 import asyncio
 from typing import Optional, List, Any, Iterable
-
+from .auto import auto_mcp
 
 class BaseMCP:
     """Base class for all Scanpy MCP classes."""
@@ -33,25 +33,20 @@ class BaseMCP:
         methods = inspect.getmembers(self, predicate=inspect.ismethod)
         
         # Filter methods that start with _tool_
-        tool_methods = {
-            name[6:]: method  # Remove '_tool_' prefix
-            for name, method in methods
-            if name.startswith('_tool_')
-        }
+        tool_methods = [tl_method() for name, tl_method in methods if name.startswith('_tool_')]
         
         # Filter tools based on include/exclude lists
         if self.include_tools is not None:
-            tool_methods = {k: v for k, v in tool_methods.items() if k in self.include_tools}
+            tool_methods = [tl for tl in tool_methods if tl.name in self.include_tools]
         
         if self.exclude_tools is not None:
-            tool_methods = {k: v for k, v in tool_methods.items() if k not in self.exclude_tools}
+            tool_methods = [tl for tl in tool_methods if tl.name not in self.exclude_tools]
 
         # Register filtered tools
-        for tool_name, tool_method in tool_methods.items():
+        for tool in tool_methods:
             # Get the function returned by the tool method
-            tool_func = tool_method()
-            if tool_func is not None:
-                self.mcp.add_tool(tool_func, name=tool_name)
+            if tool is not None:
+                self.mcp.add_tool(tool)
 
 
 class AdataState:

scmcp_shared/server/io.py

@@ -3,6 +3,7 @@ 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 *
@@ -16,7 +17,7 @@ class ScanpyIOMCP(BaseMCP):
         super().__init__("SCMCP-IO-Server", include_tools, exclude_tools, AdataInfo)
 
     def _tool_read(self):
-        def _read(request: ReadModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _read(request: ReadParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """
             Read data from 10X directory or various file formats (h5ad, 10x, text files, etc.).
             """
@@ -66,10 +67,10 @@ class ScanpyIOMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _read
+        return Tool.from_function(_read, name="read")
 
     def _tool_write(self):
-        def _write(request: WriteModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _write(request: WriteParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """save adata into a file."""
             try:
                 res = forward_request("io_write", request, adinfo)
@@ -87,7 +88,7 @@ class ScanpyIOMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _write
+        return Tool.from_function(_write, name="write")
 
 
 # Create an instance of the class

scmcp_shared/server/pl.py

@@ -3,6 +3,7 @@ import inspect
 from functools import partial
 import scanpy as sc
 from fastmcp import FastMCP, Context
+from fastmcp.tools.tool import Tool
 from fastmcp.exceptions import ToolError
 from ..schema.pl import *
 from ..schema import AdataInfo
@@ -24,7 +25,7 @@ class ScanpyPlottingMCP(BaseMCP):
         super().__init__("ScanpyMCP-PL-Server", include_tools, exclude_tools, AdataInfo)
 
     def _tool_pca(self):
-        def _pca(request: PCAModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _pca(request: PCAParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Scatter plot in PCA coordinates. default figure for PCA plot"""
             try:
                 if (res := forward_request("pl_pca", request, adinfo)) is not None:
@@ -39,10 +40,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _pca
+        return Tool.from_function(_pca, name="pca")
 
     def _tool_diffmap(self):
-        def _diffmap(request: DiffusionMapModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _diffmap(request: DiffusionMapParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Plot diffusion map embedding of cells."""
             try:
                 if (res := forward_request("pl_diffmap", request, adinfo)) is not None:
@@ -57,10 +58,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _diffmap
+        return Tool.from_function(_diffmap, name="diffmap")
 
     def _tool_violin(self):
-        def _violin(request: ViolinModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _violin(request: ViolinParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Plot violin plot of one or more variables."""
             try:
                 if (res := forward_request("pl_violin", request, adinfo)) is not None:
@@ -77,10 +78,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _violin
+        return Tool.from_function(_violin, name="violin")
 
     def _tool_stacked_violin(self):
-        def _stacked_violin(request: StackedViolinModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _stacked_violin(request: StackedViolinParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Plot stacked violin plots. Makes a compact image composed of individual violin plots stacked on top of each other."""
             try:
                 if (res := forward_request("pl_stacked_violin", request, adinfo)) is not None:
@@ -95,10 +96,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _stacked_violin
+        return Tool.from_function(_stacked_violin, name="stacked_violin")
 
     def _tool_heatmap(self):
-        async def _heatmap(request: HeatmapModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        async def _heatmap(request: HeatmapParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Heatmap of the expression values of genes."""
             try:
                 if (res := forward_request("pl_heatmap", request, adinfo)) is not None:
@@ -113,10 +114,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _heatmap
+        return Tool.from_function(_heatmap, name="heatmap")
 
     def _tool_dotplot(self):
-        def _dotplot(request: DotplotModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _dotplot(request: DotplotParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Plot dot plot of expression values per gene for each group."""
             try:
                 if (res := forward_request("pl_dotplot", request, adinfo)) is not None:
@@ -131,10 +132,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _dotplot
+        return Tool.from_function(_dotplot, name="dotplot")
 
     def _tool_matrixplot(self):
-        def _matrixplot(request: MatrixplotModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _matrixplot(request: MatrixplotParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """matrixplot, Create a heatmap of the mean expression values per group of each var_names."""
             try:
                 if (res := forward_request("pl_matrixplot", request, adinfo)) is not None:
@@ -149,10 +150,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _matrixplot
+        return Tool.from_function(_matrixplot, name="matrixplot")
 
     def _tool_tracksplot(self):
-        def _tracksplot(request: TracksplotModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _tracksplot(request: TracksplotParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """tracksplot, compact plot of expression of a list of genes."""
             try:
                 if (res := forward_request("pl_tracksplot", request, adinfo)) is not None:
@@ -167,10 +168,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _tracksplot
+        return Tool.from_function(_tracksplot, name="tracksplot")
 
     def _tool_scatter(self):
-        def _scatter(request: EnhancedScatterModel, adinfo: self.AdataInfo=self.AdataInfo()):    
+        def _scatter(request: EnhancedScatterParams, adinfo: self.AdataInfo=self.AdataInfo()):    
             """Plot a scatter plot of two variables, Scatter plot along observations or variables axes."""
             try:
                 if (res := forward_request("pl_scatter", request, adinfo)) is not None:
@@ -185,10 +186,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _scatter
+        return Tool.from_function(_scatter, name="scatter")
 
     def _tool_embedding(self):
-        def _embedding(request: EmbeddingModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _embedding(request: EmbeddingParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Scatter plot for user specified embedding basis (e.g. umap, tsne, etc)."""
             try:
                 if (res := forward_request("pl_embedding", request, adinfo)) is not None:
@@ -203,10 +204,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _embedding
+        return Tool.from_function(_embedding, name="embedding")
 
     def _tool_embedding_density(self):
-        def _embedding_density(request: EmbeddingDensityModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _embedding_density(request: EmbeddingDensityParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Plot the density of cells in an embedding."""
             try:
                 if (res := forward_request("pl_embedding_density", request, adinfo)) is not None:
@@ -221,10 +222,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _embedding_density
+        return Tool.from_function(_embedding_density, name="embedding_density")
 
     def _tool_rank_genes_groups(self):
-        def _rank_genes_groups(request: RankGenesGroupsModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _rank_genes_groups(request: RankGenesGroupsParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Plot ranking of genes based on differential expression."""
             try:
                 if (res := forward_request("pl_rank_genes_groups", request, adinfo)) is not None:
@@ -239,10 +240,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _rank_genes_groups
+        return Tool.from_function(_rank_genes_groups, name="rank_genes_groups")
 
     def _tool_rank_genes_groups_dotplot(self):
-        def _rank_genes_groups_dotplot(request: RankGenesGroupsDotplotModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _rank_genes_groups_dotplot(request: RankGenesGroupsDotplotParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Plot ranking of genes(DEGs) using dotplot visualization. Defualt plot DEGs for rank_genes_groups tool"""
             try:
                 if (res := forward_request("pl_rank_genes_groups_dotplot", request, adinfo)) is not None:
@@ -257,10 +258,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _rank_genes_groups_dotplot
+        return Tool.from_function(_rank_genes_groups_dotplot, name="rank_genes_groups_dotplot")
 
     def _tool_clustermap(self):
-        def _clustermap(request: ClusterMapModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _clustermap(request: ClusterMapParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Plot hierarchical clustering of cells and genes."""
             try:
                 if (res := forward_request("pl_clustermap", request, adinfo)) is not None:
@@ -275,10 +276,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _clustermap
+        return Tool.from_function(_clustermap, name="clustermap")
 
     def _tool_highly_variable_genes(self):
-        def _highly_variable_genes(request: HighlyVariableGenesModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _highly_variable_genes(request: HighlyVariableGenesParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """plot highly variable genes; Plot dispersions or normalized variance versus means for genes."""
             try:
                 if (res := forward_request("pl_highly_variable_genes", request, adinfo)) is not None:
@@ -293,10 +294,10 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _highly_variable_genes
+        return Tool.from_function(_highly_variable_genes, name="highly_variable_genes")
 
     def _tool_pca_variance_ratio(self):
-        def _pca_variance_ratio(request: PCAVarianceRatioModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _pca_variance_ratio(request: PCAVarianceRatioParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Plot the PCA variance ratio to visualize explained variance."""
             try:
                 if (res := forward_request("pl_pca_variance_ratio", request, adinfo)) is not None:
@@ -311,5 +312,5 @@ class ScanpyPlottingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _pca_variance_ratio
+        return Tool.from_function(_pca_variance_ratio, name="pca_variance_ratio")
 

scmcp_shared/server/pp.py

@@ -2,6 +2,7 @@ import os
 import inspect
 import scanpy as sc
 from fastmcp import FastMCP, Context
+from fastmcp.tools.tool import Tool
 from fastmcp.exceptions import ToolError
 from ..schema.pp import *
 from ..schema import AdataInfo
@@ -22,7 +23,7 @@ class ScanpyPreprocessingMCP(BaseMCP):
         super().__init__("ScanpyMCP-PP-Server", include_tools, exclude_tools, AdataInfo)
 
     def _tool_subset_cells(self):
-        def _subset_cells(request: SubsetCellModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _subset_cells(request: SubsetCellParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """filter or subset cells based on total genes expressed counts and numbers. or values in adata.obs[obs_key]"""
             try:
                 result = forward_request("subset_cells", request, adinfo)
@@ -62,10 +63,10 @@ class ScanpyPreprocessingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _subset_cells
+        return Tool.from_function(_subset_cells, name="subset_cells")
 
     def _tool_subset_genes(self):
-        def _subset_genes(request: SubsetGeneModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _subset_genes(request: SubsetGeneParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """filter or subset genes based on number of cells or counts, or values in adata.var[var_key] or subset highly variable genes"""
             try:
                 result = forward_request("pp_subset_genes", request, adinfo)
@@ -74,6 +75,11 @@ class ScanpyPreprocessingMCP(BaseMCP):
                 func_kwargs = filter_args(request, sc.pp.filter_genes)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo).copy()
+                if request.highly_variable:
+                    adata = adata[:, adata.var.highly_variable]
+                    add_op_log(adata, "subset_genes", 
+                        {"hpv":  "true"}, adinfo
+                    )
                 if func_kwargs:
                     sc.pp.filter_genes(adata, **func_kwargs)
                     add_op_log(adata, sc.pp.filter_genes, func_kwargs, adinfo)
@@ -86,8 +92,6 @@ class ScanpyPreprocessingMCP(BaseMCP):
                     if request.var_max is not None:
                         mask = mask & (adata.var[request.var_key] <= request.var_max)        
                     adata = adata[:, mask]
-                    if request.highly_variable:
-                        adata = adata[:, mask & adata.var.highly_variable]
                     add_op_log(adata, "subset_genes", 
                         {
                         "var_key": request.var_key,  "var_min": request.var_min, "var_max": request.var_max, 
@@ -103,7 +107,7 @@ class ScanpyPreprocessingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _subset_genes
+        return Tool.from_function(_subset_genes, name="subset_genes")
 
     def _tool_calculate_qc_metrics(self):
         def _calculate_qc_metrics(request: CalculateQCMetrics, adinfo: self.AdataInfo=self.AdataInfo()):
@@ -116,12 +120,16 @@ class ScanpyPreprocessingMCP(BaseMCP):
                 func_kwargs = filter_args(request, sc.pp.calculate_qc_metrics)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
+                if request.qc_vars:
+                    for var in request.qc_vars:
+                        if var not in adata.var.columns:
+                            return f"Cound find {var} in adata.var, consider to use mark_var tool to mark the variable"
                 func_kwargs["inplace"] = True
                 try:
                     sc.pp.calculate_qc_metrics(adata, **func_kwargs)
                     add_op_log(adata, sc.pp.calculate_qc_metrics, func_kwargs, adinfo)
                 except KeyError as e:
-                    raise KeyError(f"Cound find {e} in adata.var")
+                    raise KeyError(f"Cound find {e} in adata.var, consider to use mark_var tool to mark the variable")
                 return [generate_msg(adinfo, adata, ads)]
             except ToolError as e:
                 raise ToolError(e)
@@ -130,10 +138,10 @@ class ScanpyPreprocessingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _calculate_qc_metrics
+        return Tool.from_function(_calculate_qc_metrics, name="calculate_qc_metrics")
 
     def _tool_log1p(self):
-        def _log1p(request: Log1PModel=Log1PModel(), adinfo: self.AdataInfo=self.AdataInfo()):
+        def _log1p(request: Log1PParams=Log1PParams(), adinfo: self.AdataInfo=self.AdataInfo()):
             """Logarithmize the data matrix"""
             try:
                 result = forward_request("pp_log1p", request, adinfo)
@@ -157,10 +165,10 @@ class ScanpyPreprocessingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _log1p
+        return Tool.from_function(_log1p, name="log1p")
 
     def _tool_normalize_total(self):
-        def _normalize_total(request: NormalizeTotalModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _normalize_total(request: NormalizeTotalParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Normalize counts per cell to the same total count"""
             try:
                 result = forward_request("pp_normalize_total", request, adinfo)
@@ -180,10 +188,10 @@ class ScanpyPreprocessingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _normalize_total
+        return Tool.from_function(_normalize_total, name="normalize_total")
 
     def _tool_highly_variable_genes(self):
-        def _highly_variable_genes(request: HighlyVariableGenesModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _highly_variable_genes(request: HighlyVariableGenesParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Annotate highly variable genes"""
             try:
                 result = forward_request("pp_highly_variable_genes", request, adinfo)
@@ -205,10 +213,10 @@ class ScanpyPreprocessingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _highly_variable_genes
+        return Tool.from_function(_highly_variable_genes, name="highly_variable_genes")
 
     def _tool_regress_out(self):
-        def _regress_out(request: RegressOutModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _regress_out(request: RegressOutParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Regress out (mostly) unwanted sources of variation."""
             try:
                 result = forward_request("pp_regress_out", request, adinfo)
@@ -228,10 +236,10 @@ class ScanpyPreprocessingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _regress_out
+        return Tool.from_function(_regress_out, name="regress_out")
 
     def _tool_scale(self):
-        def _scale(request: ScaleModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _scale(request: ScaleParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Scale data to unit variance and zero mean"""
             try:
                 result = forward_request("pp_scale", request, adinfo)
@@ -253,10 +261,10 @@ class ScanpyPreprocessingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _scale
+        return Tool.from_function(_scale, name="scale")
 
     def _tool_combat(self):
-        def _combat(request: CombatModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _combat(request: CombatParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """ComBat function for batch effect correction"""
             try:
                 result = forward_request("pp_combat", request, adinfo)
@@ -278,10 +286,10 @@ class ScanpyPreprocessingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _combat
+        return Tool.from_function(_combat, name="combat")
 
     def _tool_scrublet(self):
-        def _scrublet(request: ScrubletModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _scrublet(request: ScrubletParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Predict doublets using Scrublet"""
             try:
                 result = forward_request("pp_scrublet", request, adinfo)
@@ -300,10 +308,10 @@ class ScanpyPreprocessingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _scrublet
+        return Tool.from_function(_scrublet, name="scrublet")
 
     def _tool_neighbors(self):
-        def _neighbors(request: NeighborsModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _neighbors(request: NeighborsParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Compute nearest neighbors distance matrix and neighborhood graph"""
             try:
                 result = forward_request("pp_neighbors", request, adinfo)
@@ -322,4 +330,4 @@ class ScanpyPreprocessingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _neighbors
+        return Tool.from_function(_neighbors, name="neighbors")