pl_tracksplot

Instructions

Implementation Reference

• src/scmcp/tool/pl.py:179-217 (handler)

  Generic handler function that executes Scanpy plotting tools, including 'pl_tracksplot'. It maps the tool name to sc.pl.tracksplot and calls it with validated arguments.

  def run_pl_func(ads, func, arguments):
      """
      Execute a Scanpy plotting function with the given arguments.
      
      Parameters
      ----------
      adata : AnnData
          Annotated data matrix.
      func : str
          Name of the plotting function to execute.
      arguments : dict
          Arguments to pass to the plotting function.
          
      Returns
      -------
      The result of the plotting function.
      """
      adata = ads.adata_dic[ads.active]
      if func not in pl_func:
          raise ValueError(f"Unsupported function: {func}")
  
      run_func = pl_func[func]
      parameters = inspect.signature(run_func).parameters
      kwargs = {k: arguments.get(k) for k in parameters if k in arguments}    
  
      if "title" not in parameters:
          kwargs.pop("title", False)    
      kwargs.pop("return_fig", True)
      kwargs["show"] = False
      kwargs["save"] = ".png"
      try:
          fig = run_func(adata, **kwargs)
          fig_path = set_fig_path(func, **kwargs)
          add_op_log(adata, run_func, kwargs)
          return fig_path 
      except Exception as e:
          raise e
      return fig_path

• src/scmcp/schema/pl.py:419-422 (schema)

  Pydantic model defining the input schema for the 'pl_tracksplot' tool. Inherits fields from BaseMatrixModel for var_names, groupby, etc.

  # 重构 TracksplotModel
  class TracksplotModel(BaseMatrixModel):
      """Input schema for the tracksplot plotting tool."""
      # 所有需要的字段已经在 BaseMatrixModel 中定义

• src/scmcp/tool/pl.py:60-64 (registration)

  MCP Tool object registration for 'pl_tracksplot', specifying name, description, and input schema.

  pl_tracksplot = types.Tool(
      name="pl_tracksplot",
      description="tracksplot,compact plot of expression of a list of genes..",
      inputSchema=TracksplotModel.model_json_schema(),
  )

• src/scmcp/tool/pl.py:130-130 (helper)

  Mapping of 'pl_tracksplot' tool name to the underlying Scanpy function sc.pl.tracksplot used in the handler.

  "pl_tracksplot": sc.pl.tracksplot,

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

  Server registration of tools via list_tools(), including pl_tools.values() which contains the 'pl_tracksplot' tool.

  @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

• src/scmcp/server.py:59-92 (handler)

  Main MCP tool call handler that dispatches 'pl_tracksplot' (in pl_tools) to run_pl_func.

  @server.call_tool()
  async def call_tool(
      name: str, arguments
  ):
      try:
          logger.info(f"Running {name} with {arguments}")
          if name in io_tools.keys():            
              res = run_io_func(ads, name, arguments)
          elif name in pp_tools.keys():
              res = run_pp_func(ads, name, arguments)
          elif name in tl_tools.keys():
              res = run_tl_func(ads, name, arguments) 
          elif name in pl_tools.keys():
              res = run_pl_func(ads, name, arguments)
          elif name in util_tools.keys():            
              res = run_util_func(ads, name, arguments)
          elif name in ccc_tools.keys():            
              res = run_ccc_func(ads.adata_dic[ads.active], name, arguments)
          output = str(res) if res is not None else str(ads.adata_dic[ads.active])
          return [
              types.TextContent(
                  type="text",
                  text=str({"output": output})
              )
          ]
      except Exception as error:
          logger.error(f"{name} with {error}")
          return [
              types.TextContent(
                  type="text",
                  text=str({"Error": error})
              )
          ]