paga

Instructions

Implementation Reference

• src/scmcp/tool/tl.py:164-177 (handler)

  Handler function that dispatches to sc.tl.paga (via tl_func mapping) and executes the core PAGA logic on the AnnData object.

  def run_tl_func(ads, func, arguments):
      adata = ads.adata_dic[ads.active]
      if func not in tl_func:
          raise ValueError(f"Unsupported function: {func}")
      run_func = tl_func[func]
      parameters = inspect.signature(run_func).parameters
      kwargs = {k: arguments.get(k) for k in parameters if k in arguments}    
      try:
          res = run_func(adata, **kwargs)
          add_op_log(adata, run_func, kwargs)
      except Exception as e:
          logger.error(f"Error running function {func}: {e}")
          raise
      return 

• src/scmcp/schema/tl.py:530-556 (schema)

  PAGAModel: Pydantic model defining the input schema and validation for the 'paga' tool parameters.

  class PAGAModel(JSONParsingModel):
      """Input schema for the Partition-based Graph Abstraction (PAGA) tool."""
      
      groups: Optional[str] = Field(
          default=None,
          description="Key for categorical in adata.obs. You can pass your predefined groups by choosing any categorical annotation of observations. Default: The first present key of 'leiden' or 'louvain'."
      )
      use_rna_velocity: bool = Field(
          default=False,
          description="Use RNA velocity to orient edges in the abstracted graph and estimate transitions. Requires that adata.uns contains a directed single-cell graph with key ['velocity_graph']."
      )
      model: Literal['v1.2', 'v1.0'] = Field(
          default='v1.2',
          description="The PAGA connectivity model."
      )
      neighbors_key: Optional[str] = Field(
          default=None,
          description="If specified, paga looks .uns[neighbors_key] for neighbors settings and uses the corresponding connectivities and distances."
      )
      
      @field_validator('model')
      def validate_model(cls, v: str) -> str:
          """Validate model version is supported"""
          if v not in ['v1.2', 'v1.0']:
              raise ValueError("model must be either 'v1.2' or 'v1.0'")
          return v

• src/scmcp/tool/tl.py:75-80 (registration)

  Definition and registration of the 'paga' MCP Tool object with name, description, and input schema.

  # Add paga tool
  paga_tool = types.Tool(
      name="paga",
      description="Partition-based graph abstraction",
      inputSchema=PAGAModel.model_json_schema(),
  )

• src/scmcp/tool/tl.py:145-162 (registration)

  tl_tools dictionary registering the 'paga_tool' under the 'paga' key for server lookup.

  tl_tools = {
      "tsne": tsne_tool,
      "umap": umap_tool,
      "draw_graph": draw_graph_tool,
      "diffmap": diffmap_tool,
      "embedding_density": embedding_density_tool,
      "leiden": leiden_tool,
      "louvain": louvain_tool,
      "dendrogram": dendrogram_tool,
      "dpt": dpt_tool,
      "paga": paga_tool,
      "ingest": ingest_tool,
      "rank_genes_groups": rank_genes_groups_tool,
      "filter_rank_genes_groups": filter_rank_genes_groups_tool,
      "marker_gene_overlap": marker_gene_overlap_tool,
      "score_genes": score_genes_tool,
      "score_genes_cell_cycle": score_genes_cell_cycle_tool,
  }

• src/scmcp/server.py:35-56 (registration)

  MCP server list_tools() method that includes 'paga' tool via tl_tools.values() for tool discovery.

  @server.list_tools()
  async def list_tools() -> list[types.Tool]:
      if MODULE == "io":
          tools = io_tools.values()
      elif MODULE == "pp":
          tools = pp_tools.values()
      elif MODULE == "tl":
          tools = tl_tools.values()
      elif MODULE == "pl":
          tools = pl_tools.values()
      elif MODULE == "util":
          tools = util_tools.values()
      else:
          tools = [
              *io_tools.values(),
              *pp_tools.values(),
              *tl_tools.values(),
              *pl_tools.values(),
              *util_tools.values(),
              *ccc_tools.values(),
          ]
      return tools