scmcp-shared 0.2.1__py3-none-any.whl → 0.2.5__py3-none-any.whl

scmcp_shared/server/tl.py

@@ -3,6 +3,7 @@ import os
 import scanpy as sc
 from fastmcp.exceptions import ToolError
 from ..schema.tl import *
+from ..schema import AdataModel
 from scmcp_shared.util import filter_args, add_op_log, forward_request, get_ads, generate_msg
 from scmcp_shared.logging_config import setup_logger
 logger = setup_logger()
@@ -12,20 +13,21 @@ tl_mcp = FastMCP("ScanpyMCP-TL-Server")
 
 @tl_mcp.tool()
 async def tsne(
-    request: TSNEModel = TSNEModel() 
+    request: TSNEModel = TSNEModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """t-distributed stochastic neighborhood embedding (t-SNE) for visualization"""
 
     try:
-        result = await forward_request("tl_tsne", request)
+        result = await forward_request("tl_tsne", request, adinfo)
         if result is not None:
             return result
         func_kwargs = filter_args(request, sc.tl.tsne)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.tsne(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.tsne, func_kwargs)
-        return generate_msg(request, adata, ads)
+        add_op_log(adata, sc.tl.tsne, func_kwargs, adinfo)
+        return generate_msg(adinfo, adata, ads)
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -37,20 +39,21 @@ async def tsne(
 
 @tl_mcp.tool()
 async def umap(
-    request: UMAPModel = UMAPModel() 
+    request: UMAPModel = UMAPModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Uniform Manifold Approximation and Projection (UMAP) for visualization"""
 
     try:
-        result = await forward_request("tl_umap", request)
+        result = await forward_request("tl_umap", request, adinfo)
         if result is not None:
             return result
         func_kwargs = filter_args(request, sc.tl.umap)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.umap(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.umap, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.umap, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -61,20 +64,21 @@ async def umap(
 
 @tl_mcp.tool()
 async def draw_graph(
-    request: DrawGraphModel = DrawGraphModel() 
+    request: DrawGraphModel = DrawGraphModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Force-directed graph drawing"""
 
     try:
-        result = await forward_request("tl_draw_graph", request)
+        result = await forward_request("tl_draw_graph", request, adinfo)
         if result is not None:
             return result    
         func_kwargs = filter_args(request, sc.tl.draw_graph)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.draw_graph(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.draw_graph, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.draw_graph, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -85,21 +89,22 @@ async def draw_graph(
 
 @tl_mcp.tool()
 async def diffmap(
-    request: DiffMapModel = DiffMapModel() 
+    request: DiffMapModel = DiffMapModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Diffusion Maps for dimensionality reduction"""
 
     try:
-        result = await forward_request("tl_diffmap", request)
+        result = await forward_request("tl_diffmap", request, adinfo)
         if result is not None:
             return result    
         func_kwargs = filter_args(request, sc.tl.diffmap)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.diffmap(adata, **func_kwargs)
         adata.obsm["X_diffmap"] = adata.obsm["X_diffmap"][:,1:]
-        add_op_log(adata, sc.tl.diffmap, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.diffmap, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -110,20 +115,21 @@ async def diffmap(
 
 @tl_mcp.tool()
 async def embedding_density(
-    request: EmbeddingDensityModel = EmbeddingDensityModel() 
+    request: EmbeddingDensityModel = EmbeddingDensityModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Calculate the density of cells in an embedding"""
 
     try:
-        result = await forward_request("tl_embedding_density", request)
+        result = await forward_request("tl_embedding_density", request, adinfo)
         if result is not None:
             return result        
         func_kwargs = filter_args(request, sc.tl.embedding_density)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.embedding_density(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.embedding_density, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.embedding_density, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -135,20 +141,21 @@ async def embedding_density(
 
 @tl_mcp.tool()
 async def leiden(
-    request: LeidenModel = LeidenModel() 
+    request: LeidenModel = LeidenModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Leiden clustering algorithm for community detection"""
 
     try:
-        result = await forward_request("tl_leiden", request)
+        result = await forward_request("tl_leiden", request, adinfo)
         if result is not None:
             return result            
         func_kwargs = filter_args(request, sc.tl.leiden)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.leiden(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.leiden, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.leiden, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -160,20 +167,21 @@ async def leiden(
 
 @tl_mcp.tool()
 async def louvain(
-    request: LouvainModel = LouvainModel() 
+    request: LouvainModel = LouvainModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Louvain clustering algorithm for community detection"""
 
     try:
-        result = await forward_request("tl_louvain", request)
+        result = await forward_request("tl_louvain", request, adinfo)
         if result is not None:
             return result          
         func_kwargs = filter_args(request, sc.tl.louvain)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.louvain(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.louvain, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.louvain, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -185,19 +193,20 @@ async def louvain(
 @tl_mcp.tool()
 async def dendrogram(
     request: DendrogramModel,
+    adinfo: AdataModel = AdataModel()
 ):
     """Hierarchical clustering dendrogram"""
 
     try:
-        result = await forward_request("tl_dendrogram", request)
+        result = await forward_request("tl_dendrogram", request, adinfo)
         if result is not None:
             return result        
         func_kwargs = filter_args(request, sc.tl.dendrogram)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.dendrogram(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.dendrogram, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.dendrogram, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -208,20 +217,21 @@ async def dendrogram(
 
 @tl_mcp.tool()
 async def dpt(
-    request: DPTModel = DPTModel() 
+    request: DPTModel = DPTModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Diffusion Pseudotime (DPT) analysis"""
 
     try:
-        result = await forward_request("tl_dpt", request)
+        result = await forward_request("tl_dpt", request, adinfo)
         if result is not None:
             return result          
         func_kwargs = filter_args(request, sc.tl.dpt)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.dpt(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.dpt, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.dpt, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -233,20 +243,21 @@ async def dpt(
 
 @tl_mcp.tool()
 async def paga(
-    request: PAGAModel = PAGAModel() 
+    request: PAGAModel = PAGAModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Partition-based graph abstraction"""
 
     try:
-        result = await forward_request("tl_paga", request)
+        result = await forward_request("tl_paga", request, adinfo)
         if result is not None:
             return result         
         func_kwargs = filter_args(request, sc.tl.paga)
         ads = get_ads()
-        adata = ads.get_adata(request=request)    
+        adata = ads.get_adata(adinfo=adinfo)    
         sc.tl.paga(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.paga, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.paga, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -258,20 +269,21 @@ async def paga(
 
 @tl_mcp.tool()
 async def ingest(
-    request: IngestModel = IngestModel() 
+    request: IngestModel = IngestModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Map labels and embeddings from reference data to new data"""
 
     try:
-        result = await forward_request("tl_ingest", request)
+        result = await forward_request("tl_ingest", request, adinfo)
         if result is not None:
             return result       
         func_kwargs = filter_args(request, sc.tl.ingest)
         ads = get_ads()
-        adata = ads.get_adata(request=request)    
+        adata = ads.get_adata(adinfo=adinfo)    
         sc.tl.ingest(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.ingest, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.ingest, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -283,20 +295,20 @@ async def ingest(
 @tl_mcp.tool()
 async def rank_genes_groups(
     request: RankGenesGroupsModel,
-
+    adinfo: AdataModel = AdataModel()
 ):
     """Rank genes for characterizing groups, for differentially expressison analysis"""
 
     try:
-        result = await forward_request("tl_rank_genes_groups", request)
+        result = await forward_request("tl_rank_genes_groups", request, adinfo)
         if result is not None:
             return result         
         func_kwargs = filter_args(request, sc.tl.rank_genes_groups)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.rank_genes_groups(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.rank_genes_groups, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.rank_genes_groups, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -308,20 +320,21 @@ async def rank_genes_groups(
 
 @tl_mcp.tool()
 async def filter_rank_genes_groups(
-    request: FilterRankGenesGroupsModel = FilterRankGenesGroupsModel() 
+    request: FilterRankGenesGroupsModel = FilterRankGenesGroupsModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Filter out genes based on fold change and fraction of genes"""
 
     try:
-        result = await forward_request("tl_filter_rank_genes_groups", request)
+        result = await forward_request("tl_filter_rank_genes_groups", request, adinfo)
         if result is not None:
             return result          
         func_kwargs = filter_args(request, sc.tl.filter_rank_genes_groups)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.filter_rank_genes_groups(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.filter_rank_genes_groups, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.filter_rank_genes_groups, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -333,20 +346,21 @@ async def filter_rank_genes_groups(
 
 @tl_mcp.tool()
 async def marker_gene_overlap(
-    request: MarkerGeneOverlapModel = MarkerGeneOverlapModel() 
+    request: MarkerGeneOverlapModel = MarkerGeneOverlapModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Calculate overlap between data-derived marker genes and reference markers"""
 
     try:
-        result = await forward_request("tl_marker_gene_overlap", request)
+        result = await forward_request("tl_marker_gene_overlap", request, adinfo)
         if result is not None:
             return result         
         func_kwargs = filter_args(request, sc.tl.marker_gene_overlap)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.marker_gene_overlap(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.marker_gene_overlap, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.marker_gene_overlap, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -358,19 +372,19 @@ async def marker_gene_overlap(
 @tl_mcp.tool()
 async def score_genes(
     request: ScoreGenesModel,
-    
+    adinfo: AdataModel = AdataModel()
 ):
     """Score a set of genes based on their average expression"""
     try:
-        result = await forward_request("tl_score_genes", request)
+        result = await forward_request("tl_score_genes", request, adinfo)
         if result is not None:
             return result       
         func_kwargs = filter_args(request, sc.tl.score_genes)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.score_genes(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.score_genes, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.score_genes, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -382,20 +396,20 @@ async def score_genes(
 @tl_mcp.tool()
 async def score_genes_cell_cycle(
     request: ScoreGenesCellCycleModel,
-    
+    adinfo: AdataModel = AdataModel()
 ):
     """Score cell cycle genes and assign cell cycle phases"""
 
     try:
-        result = await forward_request("tl_score_genes_cell_cycle", request)
+        result = await forward_request("tl_score_genes_cell_cycle", request, adinfo)
         if result is not None:
             return result       
         func_kwargs = filter_args(request, sc.tl.score_genes_cell_cycle)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.tl.score_genes_cell_cycle(adata, **func_kwargs)
-        add_op_log(adata, sc.tl.score_genes_cell_cycle, func_kwargs)
-        return [generate_msg(request, adata, ads)]
+        add_op_log(adata, sc.tl.score_genes_cell_cycle, func_kwargs, adinfo)
+        return [generate_msg(adinfo, adata, ads)]
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -407,21 +421,22 @@ async def score_genes_cell_cycle(
 
 @tl_mcp.tool()
 async def pca(
-    request: PCAModel = PCAModel() 
+    request: PCAModel = PCAModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Principal component analysis"""
 
     try:
-        result = await forward_request("tl_pca", request)
+        result = await forward_request("tl_pca", request, adinfo)
         if result is not None:
             return result
         func_kwargs = filter_args(request, sc.pp.pca)
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         sc.pp.pca(adata, **func_kwargs)
-        add_op_log(adata, sc.pp.pca, func_kwargs)
+        add_op_log(adata, sc.pp.pca, func_kwargs, adinfo)
         return [
-            generate_msg(request, adata, ads)
+            generate_msg(adinfo, adata, ads)
         ]
     except ToolError as e:
         raise ToolError(e)

scmcp_shared/server/util.py

@@ -5,6 +5,7 @@ import scanpy as sc
 from fastmcp import FastMCP , Context
 from fastmcp.exceptions import ToolError
 from ..schema.util import *
+from ..schema import AdataModel
 from ..util import filter_args, forward_request, get_ads, generate_msg,add_op_log
 
 
@@ -12,9 +13,12 @@ ul_mcp = FastMCP("SCMCP-Util-Server")
 
 
 @ul_mcp.tool()
-async def query_op_log(request: QueryOpLogModel = QueryOpLogModel()):
+async def query_op_log(
+    request: QueryOpLogModel = QueryOpLogModel(),
+    adinfo: AdataModel = AdataModel()
+):
     """Query the adata operation log"""
-    adata = get_ads().get_adata(request=request)
+    adata = get_ads().get_adata(adinfo=adinfo)
     op_dic = adata.uns["operation"]["op"]
     opids = adata.uns["operation"]["opid"][-n:]
     op_list = []
@@ -25,7 +29,8 @@ async def query_op_log(request: QueryOpLogModel = QueryOpLogModel()):
 
 @ul_mcp.tool()
 async def mark_var(
-    request: MarkVarModel = MarkVarModel() 
+    request: MarkVarModel = MarkVarModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """
     Determine if each gene meets specific conditions and store results in adata.var as boolean values.
@@ -33,10 +38,10 @@ async def mark_var(
     The tool should be called first when calculate quality control metrics for mitochondrion, ribosomal, harhemoglobin genes, or other qc_vars.
     """
     try:
-        result = await forward_request("ul_mark_var", request)
+        result = await forward_request("ul_mark_var", request, adinfo)
         if result is not None:
             return result
-        adata = get_ads().get_adata(request=request)
+        adata = get_ads().get_adata(adinfo=adinfo)
         var_name = request.var_name
         gene_class = request.gene_class
         pattern_type = request.pattern_type
@@ -65,7 +70,7 @@ async def mark_var(
     
         res = {var_name: adata.var[var_name].value_counts().to_dict(), "msg": f"add '{var_name}' column in adata.var"}
         func_kwargs = {"var_name": var_name, "gene_class": gene_class, "pattern_type": pattern_type, "patterns": patterns}
-        add_op_log(adata, "mark_var", func_kwargs)
+        add_op_log(adata, "mark_var", func_kwargs, adinfo)
         return res
     except ToolError as e:
         raise ToolError(e)
@@ -78,16 +83,17 @@ async def mark_var(
 
 @ul_mcp.tool()
 async def list_var(
-    request: ListVarModel = ListVarModel() 
+    request: ListVarModel = ListVarModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """List key columns in adata.var. It should be called for checking when other tools need var key column names as input."""
     try:
-        result = await forward_request("ul_list_var", request)
+        result = await forward_request("ul_list_var", request, adinfo)
         if result is not None:
             return result
-        adata = get_ads().get_adata(request=request)
+        adata = get_ads().get_adata(adinfo=adinfo)
         columns = list(adata.var.columns)
-        add_op_log(adata, list_var, {})
+        add_op_log(adata, list_var, {}, adinfo)
         return columns
     except ToolError as e:
         raise ToolError(e)
@@ -99,16 +105,17 @@ async def list_var(
 
 @ul_mcp.tool()
 async def list_obs(
-    request: ListObsModel = ListObsModel() 
+    request: ListObsModel = ListObsModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """List key columns in adata.obs. It should be called before other tools need obs key column names input."""
     try:
-        result = await forward_request("ul_list_obs", request)
+        result = await forward_request("ul_list_obs", request, adinfo)
         if result is not None:
             return result    
-        adata = get_ads().get_adata(request=request)
+        adata = get_ads().get_adata(adinfo=adinfo)
         columns = list(adata.obs.columns)
-        add_op_log(adata, list_obs, {})
+        add_op_log(adata, list_obs, {}, adinfo)
         return columns
     except ToolError as e:
         raise ToolError(e)
@@ -120,17 +127,18 @@ async def list_obs(
 
 @ul_mcp.tool()
 async def check_var(
-    request: VarNamesModel = VarNamesModel() 
+    request: VarNamesModel = VarNamesModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Check if genes/variables exist in adata.var_names. This tool should be called before gene expression visualizations or color by genes."""
     try:
-        result = await forward_request("ul_check_var", request)
+        result = await forward_request("ul_check_var", request, adinfo)
         if result is not None:
             return result     
-        adata = get_ads().get_adata(request=request)
+        adata = get_ads().get_adata(adinfo=adinfo)
         var_names = request.var_names
         result = {v: v in adata.var_names for v in var_names}
-        add_op_log(adata, check_var, {"var_names": var_names})
+        add_op_log(adata, check_var, {"var_names": var_names}, adinfo)
         return result
     except ToolError as e:
         raise ToolError(e)
@@ -142,21 +150,22 @@ async def check_var(
 
 @ul_mcp.tool()
 async def merge_adata(
-    request: ConcatAdataModel = ConcatAdataModel() 
+    request: ConcatBaseModel = ConcatBaseModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Merge multiple adata objects."""
      
     try:
-        result = await forward_request("ul_merge_adata", request)
+        result = await forward_request("ul_merge_adata", request, adinfo)
         if result is not None:
             return result
         ads = get_ads()
-        adata = ads.get_adata(request=request)
+        adata = ads.get_adata(adinfo=adinfo)
         kwargs = {k: v for k, v in request.model_dump().items() if v is not None}
         merged_adata = adata.concat(list(ads.adata_dic[dtype].values()), **kwargs)
         ads.adata_dic[dtype] = {}
         ads.active_id = "merged_adata"
-        add_op_log(merged_adata, ad.concat, kwargs)
+        add_op_log(merged_adata, ad.concat, kwargs, adinfo)
         ads.adata_dic[ads.active_id] = merged_adata
         return {"status": "success", "message": "Successfully merged all AnnData objects"}
     except ToolError as e:
@@ -171,14 +180,14 @@ async def merge_adata(
 @ul_mcp.tool()
 async def set_dpt_iroot(
     request: DPTIROOTModel,
-    
+    adinfo: AdataModel = AdataModel()
 ):
     """Set the iroot cell"""
     try:
-        result = await forward_request("ul_set_dpt_iroot", request)
+        result = await forward_request("ul_set_dpt_iroot", request, adinfo)
         if result is not None:
             return result     
-        adata = get_ads().get_adata(request=request)
+        adata = get_ads().get_adata(adinfo=adinfo)
         diffmap_key = request.diffmap_key
         dimension = request.dimension
         direction = request.direction
@@ -190,7 +199,7 @@ async def set_dpt_iroot(
             adata.uns["iroot"] = adata.obsm[diffmap_key][:, dimension].argmax()
         
         func_kwargs = {"diffmap_key": diffmap_key, "dimension": dimension, "direction": direction}
-        add_op_log(adata, "set_dpt_iroot", func_kwargs)
+        add_op_log(adata, "set_dpt_iroot", func_kwargs, adinfo)
         
         return {"status": "success", "message": f"Successfully set root cell for DPT using {direction} of dimension {dimension}"}
     except ToolError as e:
@@ -204,14 +213,15 @@ async def set_dpt_iroot(
 @ul_mcp.tool()
 async def add_layer(
     request: AddLayerModel,
+    adinfo: AdataModel = AdataModel()
 ):
     """Add a layer to the AnnData object.
     """
     try:
-        result = await forward_request("ul_add_layer", request)
+        result = await forward_request("ul_add_layer", request, adinfo)
         if result is not None:
             return result         
-        adata = get_ads().get_adata(request=request)
+        adata = get_ads().get_adata(adinfo=adinfo)
         layer_name = request.layer_name
         
         # Check if layer already exists
@@ -221,7 +231,7 @@ async def add_layer(
         adata.layers[layer_name] = adata.X.copy()
 
         func_kwargs = {"layer_name": layer_name}
-        add_op_log(adata, "add_layer", func_kwargs)
+        add_op_log(adata, "add_layer", func_kwargs, adinfo)
         
         return {
             "status": "success",