Skip to main content
Glama

pl_highly_variable_genes

Identify and visualize highly variable genes in single-cell RNA-seq data by plotting gene dispersions or normalized variance versus means to highlight biologically relevant features.

Instructions

plot highly variable genes; Plot dispersions or normalized variance versus means for genes.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
figsizeNoFigure size. Format is (width, height).
color_mapNoColor map to use for continuous variables.
paletteNoColors to use for plotting categorical annotation groups.
vmaxNoThe value representing the upper limit of the color scale.
vminNoThe value representing the lower limit of the color scale.
vcenterNoThe value representing the center of the color scale.
legend_fontsizeNoNumeric size in pt or string describing the size.
legend_fontweightNoLegend font weight. A numeric value in range 0-1000 or a string.bold
legend_locNoLocation of legend, either 'on data', 'right margin' or a valid keyword for the loc parameter.right margin
legend_fontoutlineNoLine width of the legend font outline in pt.
logNoPlot on logarithmic axes.
highly_variable_genesNoWhether to plot highly variable genes or all genes.

Implementation Reference

  • Handler function that executes pl_highly_variable_genes by calling sc.pl.highly_variable_genes(adata, **validated_kwargs) and handles figure saving.
    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
  • Pydantic input schema model used by the tool for validation.
    class HighlyVariableGenesModel(BaseVisualizationModel):
        """Input schema for the highly_variable_genes plotting tool."""
        
        log: bool = Field(
            default=False,
            description="Plot on logarithmic axes."
        )
        
        highly_variable_genes: bool = Field(
            default=True,
            description="Whether to plot highly variable genes or all genes."
        )
  • Definition of the MCP Tool object.
    pl_highly_variable_genes = types.Tool(
        name="pl_highly_variable_genes",
        description="plot highly variable genes; Plot dispersions or normalized variance versus means for genes.",
        inputSchema=HighlyVariableGenesModel.model_json_schema(),
    )
  • Mapping of tool name to the underlying Scanpy plotting function.
    pl_func = {
        "pl_pca": sc.pl.pca,
        "pl_embedding": sc.pl.embedding,  # Add the new embedding function
        "diffmap": sc.pl.diffmap,
        "pl_violin": sc.pl.violin,
        "pl_stacked_violin": sc.pl.stacked_violin,
        "pl_heatmap": sc.pl.heatmap,
        "pl_dotplot": sc.pl.dotplot,
        "pl_matrixplot": sc.pl.matrixplot,
        "pl_tracksplot": sc.pl.tracksplot,
        "pl_scatter": sc.pl.scatter,
        "embedding_density": sc.pl.embedding_density,
        "rank_genes_groups": sc.pl.rank_genes_groups,
        "pl_rank_genes_groups_dotplot": sc.pl.rank_genes_groups_dotplot,  # Add function mapping
        "pl_clustermap": sc.pl.clustermap,
        "pl_highly_variable_genes": sc.pl.highly_variable_genes,
        "pl_pca_variance_ratio": sc.pl.pca_variance_ratio,
    }
  • Registration of the tool in the pl_tools dictionary used by the server.
    pl_tools = {
        "pl_pca": pl_pca_tool,
        "pl_embedding": pl_embedding,  # Add the new embedding tool
        # "diffmap": diffmap,
        "pl_violin": pl_violin,
        "pl_stacked_violin": pl_stacked_violin,
        "pl_heatmap": pl_heatmap,
        "pl_dotplot": pl_dotplot,
        "pl_matrixplot": pl_matrixplot,
        "pl_tracksplot": pl_tracksplot,
        "pl_scatter": pl_scatter,
        # "embedding_density": embedding_density,
        # "spatial": spatial,
        # "rank_genes_groups": rank_genes_groups,
        "pl_rank_genes_groups_dotplot": pl_rank_genes_groups_dotplot,  # Add tool mapping
        # "pl_clustermap": pl_clustermap,
        "pl_highly_variable_genes": pl_highly_variable_genes,
        "pl_pca_variance_ratio": pl_pca_variance_ratio,
    }
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tool generates a plot but fails to describe key traits: it doesn't specify if this is a read-only operation, what data source it uses (e.g., from prior analysis like 'highly_variable_genes'), the output format (e.g., image file, display), or any side effects like saving files. This leaves significant gaps in understanding the tool's behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and front-loaded, stating the purpose in a single sentence with no wasted words. It efficiently communicates the core action ('plot highly variable genes') and visualization type ('dispersions or normalized variance versus means'), making it easy to parse, though it could benefit from slightly more structure to enhance clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of a plotting tool with 12 parameters, no annotations, and no output schema, the description is incomplete. It lacks information on behavioral traits (e.g., output format, data dependencies), usage context, and how it integrates with sibling tools. While the schema covers parameters well, the description fails to compensate for other gaps, making it inadequate for full agent understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, providing clear details for all 12 parameters (e.g., 'figsize' for figure dimensions, 'log' for logarithmic axes). The description adds no additional parameter semantics beyond the schema, as it doesn't explain how parameters interact or their impact on the plot. Given the high schema coverage, a baseline score of 3 is appropriate, as the schema adequately documents parameters without extra help from the description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states the tool 'plot[s] highly variable genes' and specifies 'Plot dispersions or normalized variance versus means for genes,' which clarifies the action and visualization type. However, it's somewhat vague about the exact statistical context (e.g., what data it operates on) and doesn't differentiate from sibling tools like 'pl_scatter' or 'pl_embedding' that might also plot gene data, leaving room for ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives, such as other plotting tools in the sibling list (e.g., 'pl_scatter' for general scatter plots or 'highly_variable_genes' for non-plotting analysis). It lacks explicit context, prerequisites, or exclusions, leaving the agent to infer usage based on the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/huang-sh/scmcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server