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

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()):
@@ -130,10 +134,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 +161,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 +184,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 +209,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 +232,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 +257,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 +282,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 +304,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 +326,4 @@ class ScanpyPreprocessingMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _neighbors
+        return Tool.from_function(_neighbors, name="neighbors")

scmcp_shared/server/tl.py

@@ -4,6 +4,7 @@ import inspect
 from fastmcp import FastMCP
 import scanpy as sc
 from fastmcp.exceptions import ToolError
+from fastmcp.tools.tool import Tool
 from ..schema.tl import *
 from ..schema import AdataInfo
 from scmcp_shared.util import filter_args, add_op_log, forward_request, get_ads, generate_msg
@@ -23,7 +24,7 @@ class ScanpyToolsMCP(BaseMCP):
         super().__init__("ScanpyMCP-TL-Server", include_tools, exclude_tools, AdataInfo)
 
     def _tool_tsne(self):
-        def _tsne(request: TSNEModel=TSNEModel(), adinfo: self.AdataInfo=self.AdataInfo()):
+        def _tsne(request: TSNEParams=TSNEParams(), adinfo: self.AdataInfo=self.AdataInfo()):
             """t-distributed stochastic neighborhood embedding (t-SNE) for visualization"""
             try:
                 result = forward_request("tl_tsne", request, adinfo)
@@ -42,10 +43,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _tsne
+        return Tool.from_function(_tsne, name="tsne")
 
     def _tool_umap(self):
-        def _umap(request: UMAPModel=UMAPModel(), adinfo: self.AdataInfo=self.AdataInfo()):
+        def _umap(request: UMAPParams=UMAPParams(), adinfo: self.AdataInfo=self.AdataInfo()):
             """Uniform Manifold Approximation and Projection (UMAP) for visualization"""
             try:
                 result = forward_request("tl_umap", request, adinfo)
@@ -64,10 +65,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _umap
+        return Tool.from_function(_umap, name="umap")
 
     def _tool_draw_graph(self):
-        def _draw_graph(request: DrawGraphModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _draw_graph(request: DrawGraphParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Force-directed graph drawing"""
             try:
                 result = forward_request("tl_draw_graph", request, adinfo)
@@ -86,10 +87,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _draw_graph
+        return Tool.from_function(_draw_graph, name="draw_graph")
 
     def _tool_diffmap(self):
-        def _diffmap(request: DiffMapModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _diffmap(request: DiffMapParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Diffusion Maps for dimensionality reduction"""
             try:
                 result = forward_request("tl_diffmap", request, adinfo)
@@ -109,10 +110,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _diffmap
+        return Tool.from_function(_diffmap, name="diffmap")
 
     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()):
             """Calculate the density of cells in an embedding"""
             try:
                 result = forward_request("tl_embedding_density", request, adinfo)
@@ -131,10 +132,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _embedding_density
+        return Tool.from_function(_embedding_density, name="embedding_density")
 
     def _tool_leiden(self):
-        def _leiden(request: LeidenModel=LeidenModel(), adinfo: self.AdataInfo=self.AdataInfo()):
+        def _leiden(request: LeidenParams=LeidenParams(), adinfo: self.AdataInfo=self.AdataInfo()):
             """Leiden clustering algorithm for community detection"""
             try:
                 result = forward_request("tl_leiden", request, adinfo)
@@ -153,10 +154,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _leiden
+        return Tool.from_function(_leiden, name="leiden")
 
     def _tool_louvain(self):
-        def _louvain(request: LouvainModel=LouvainModel(), adinfo: self.AdataInfo=self.AdataInfo()):
+        def _louvain(request: LouvainParams=LouvainParams(), adinfo: self.AdataInfo=self.AdataInfo()):
             """Louvain clustering algorithm for community detection"""
             try:
                 result = forward_request("tl_louvain", request, adinfo)
@@ -175,10 +176,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _louvain
+        return Tool.from_function(_louvain, name="louvain")
 
     def _tool_dendrogram(self):
-        def _dendrogram(request: DendrogramModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _dendrogram(request: DendrogramParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Hierarchical clustering dendrogram"""
             try:
                 result = forward_request("tl_dendrogram", request, adinfo)
@@ -197,10 +198,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _dendrogram
+        return Tool.from_function(_dendrogram, name="dendrogram")
 
     def _tool_dpt(self):
-        def _dpt(request: DPTModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _dpt(request: DPTParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Diffusion Pseudotime (DPT) analysis"""
             try:
                 result = forward_request("tl_dpt", request, adinfo)
@@ -219,10 +220,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _dpt
+        return Tool.from_function(_dpt, name="dpt")
 
     def _tool_paga(self):
-        def _paga(request: PAGAModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _paga(request: PAGAParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Partition-based graph abstraction"""
             try:
                 result = forward_request("tl_paga", request, adinfo)
@@ -241,10 +242,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _paga
+        return Tool.from_function(_paga, name="paga")
 
     def _tool_ingest(self):
-        def _ingest(request: IngestModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _ingest(request: IngestParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Map labels and embeddings from reference data to new data"""
             try:
                 result = forward_request("tl_ingest", request, adinfo)
@@ -263,10 +264,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _ingest
+        return Tool.from_function(_ingest, name="ingest")   
 
     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()):
             """Rank genes for characterizing groups, for differentially expressison analysis"""
             try:
                 result = forward_request("tl_rank_genes_groups", request, adinfo)
@@ -285,10 +286,10 @@ class ScanpyToolsMCP(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_filter_rank_genes_groups(self):
-        def _filter_rank_genes_groups(request: FilterRankGenesGroupsModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _filter_rank_genes_groups(request: FilterRankGenesGroupsParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Filter out genes based on fold change and fraction of genes"""
             try:
                 result = forward_request("tl_filter_rank_genes_groups", request, adinfo)
@@ -307,10 +308,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _filter_rank_genes_groups
+        return Tool.from_function(_filter_rank_genes_groups, name="filter_rank_genes_groups")
 
     def _tool_marker_gene_overlap(self):
-        def _marker_gene_overlap(request: MarkerGeneOverlapModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _marker_gene_overlap(request: MarkerGeneOverlapParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Calculate overlap between data-derived marker genes and reference markers"""
             try:
                 result = forward_request("tl_marker_gene_overlap", request, adinfo)
@@ -329,10 +330,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _marker_gene_overlap
+        return Tool.from_function(_marker_gene_overlap, name="marker_gene_overlap")
 
     def _tool_score_genes(self):
-        def _score_genes(request: ScoreGenesModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _score_genes(request: ScoreGenesParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Score a set of genes based on their average expression"""
             try:
                 result = forward_request("tl_score_genes", request, adinfo)
@@ -351,10 +352,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _score_genes
+        return Tool.from_function(_score_genes, name="score_genes")
 
     def _tool_score_genes_cell_cycle(self):
-        def _score_genes_cell_cycle(request: ScoreGenesCellCycleModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _score_genes_cell_cycle(request: ScoreGenesCellCycleParams, adinfo: self.AdataInfo=self.AdataInfo()):
             """Score cell cycle genes and assign cell cycle phases"""
             try:
                 result = forward_request("tl_score_genes_cell_cycle", request, adinfo)
@@ -373,10 +374,10 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _score_genes_cell_cycle
+        return Tool.from_function(_score_genes_cell_cycle, name="score_genes_cell_cycle")
 
     def _tool_pca(self):
-        def _pca(request: PCAModel=PCAModel(), adinfo: self.AdataInfo=self.AdataInfo()):
+        def _pca(request: PCAParams=PCAParams(), adinfo: self.AdataInfo=self.AdataInfo()):
             """Compute PCA (Principal Component Analysis)."""
             try:
                 result = forward_request("tl_pca", request, adinfo)
@@ -395,4 +396,4 @@ class ScanpyToolsMCP(BaseMCP):
                     raise ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return _pca
+        return Tool.from_function(_pca, name="pca")