Skip to main content
Glama
taehojo

AlphaGenome MCP Server

by taehojo
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Remote

batch_tissue_comparison

Analyze genetic variants across multiple tissues simultaneously to identify tissue-specific effects in large-scale genomic studies.

Instructions

Analyze multiple variants across multiple tissues.

Efficient batch analysis of variants × tissues combinations.

Perfect for: large-scale tissue-specificity studies.

Example: "Test 10 variants in brain, liver, heart"

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
variantsYes
tissuesYes

Implementation Reference

  • src/tools.ts:391-425 (schema)
    Defines the input schema and metadata for the batch_tissue_comparison tool, including validation for variants (array of chromosome, position, ref, alt) and tissues arrays.
    export const BATCH_TISSUE_COMPARISON_TOOL: Tool = {
  name: 'batch_tissue_comparison',
  description: `Analyze multiple variants across multiple tissues.

Efficient batch analysis of variants × tissues combinations.

Perfect for: large-scale tissue-specificity studies.

Example: "Test 10 variants in brain, liver, heart"`,
  inputSchema: {
    type: 'object',
    properties: {
      variants: {
        type: 'array',
        items: {
          type: 'object',
          properties: {
            chromosome: { type: 'string' },
            position: { type: 'number' },
            ref: { type: 'string' },
            alt: { type: 'string' },
          },
          required: ['chromosome', 'position', 'ref', 'alt'],
        },
        minItems: 1,
      },
      tissues: {
        type: 'array',
        items: { type: 'string' },
        minItems: 1,
      },
    },
    required: ['variants', 'tissues'],
  },
};
  • scripts/alphagenome_bridge.py:451-483 (handler)
    Core implementation of batch_tissue_comparison: iterates over variants and tissues, calls predict_variant_effect for each combination, aggregates impact and expression fold-change results.
    def batch_tissue_comparison(client, params: Dict[str, Any]) -> Dict[str, Any]:
    """
    Analyze multiple variants across multiple tissues.
    """
    variants_data = params.get('variants', [])
    tissues = params.get('tissues', ['brain', 'liver', 'heart'])

    results = []
    for v in variants_data:
        var_id = f"{v.get('chromosome')}:{v.get('position')}{v.get('ref')}>{v.get('alt')}"
        tissue_results = {}

        for tissue in tissues:
            v['tissue_type'] = tissue
            try:
                result = predict_variant_effect(client, v)
                tissue_results[tissue] = {
                    'impact': result['interpretation']['impact_level'],
                    'expression_fc': result['predictions'].get('rna_seq', {}).get('fold_change', 0)
                }
            except Exception as e:
                tissue_results[tissue] = {'error': str(e)}

        results.append({
            'variant': var_id,
            'tissues': tissue_results
        })

    return {
        'total_variants': len(results),
        'tissues_tested': tissues,
        'results': results
    }
  • src/index.ts:198-203 (registration)
    MCP server registration: handles tool calls for batch_tissue_comparison by invoking the AlphaGenome client method.
    case 'batch_tissue_comparison': {
  const result = await getClient().batchTissueComparison(args);
  return {
    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
  };
}
  • src/tools.ts:425-719 (registration)
    Tool registration: includes BATCH_TISSUE_COMPARISON_TOOL in the ALL_TOOLS export array for MCP tool discovery.
    };

// Group C Tools: Occasionally Useful

export const PREDICT_TF_BINDING_IMPACT_TOOL: Tool = {
  name: 'predict_tf_binding_impact',
  description: `Focus on transcription factor binding effects only.

Analyzes TF binding site changes using ChIP-seq predictions.

Perfect for: TF binding site variants, regulatory element analysis.

Example: "Analyze TF binding impact of chr1:12345678G>A"`,
  inputSchema: {
    type: 'object',
    properties: {
      chromosome: { type: 'string', pattern: '^chr([1-9]|1[0-9]|2[0-2]|X|Y)$' },
      position: { type: 'number', minimum: 1 },
      ref: { type: 'string', pattern: '^[ATGCatgc]+$' },
      alt: { type: 'string', pattern: '^[ATGCatgc]+$' },
      tissue_type: { type: 'string' },
    },
    required: ['chromosome', 'position', 'ref', 'alt'],
  },
};

export const PREDICT_CHROMATIN_IMPACT_TOOL: Tool = {
  name: 'predict_chromatin_impact',
  description: `Focus on chromatin accessibility effects only.

Analyzes DNase and ATAC-seq predictions for chromatin state changes.

Perfect for: enhancer variants, regulatory region analysis.

Example: "Analyze chromatin impact of chr2:23456789C>T"`,
  inputSchema: {
    type: 'object',
    properties: {
      chromosome: { type: 'string', pattern: '^chr([1-9]|1[0-9]|2[0-2]|X|Y)$' },
      position: { type: 'number', minimum: 1 },
      ref: { type: 'string', pattern: '^[ATGCatgc]+$' },
      alt: { type: 'string', pattern: '^[ATGCatgc]+$' },
      tissue_type: { type: 'string' },
    },
    required: ['chromosome', 'position', 'ref', 'alt'],
  },
};

export const COMPARE_PROTECTIVE_RISK_TOOL: Tool = {
  name: 'compare_protective_risk',
  description: `Compare protective vs risk alleles directly.

Side-by-side comparison of alleles with opposite disease associations.

Perfect for: disease mechanism studies, therapeutic target identification.

Example: "Compare APOE protective allele vs risk allele"`,
  inputSchema: {
    type: 'object',
    properties: {
      protective_variant: {
        type: 'object',
        properties: {
          chromosome: { type: 'string', pattern: '^chr([1-9]|1[0-9]|2[0-2]|X|Y)$' },
          position: { type: 'number', minimum: 1 },
          ref: { type: 'string', pattern: '^[ATGCatgc]+$' },
          alt: { type: 'string', pattern: '^[ATGCatgc]+$' },
        },
        required: ['chromosome', 'position', 'ref', 'alt'],
      },
      risk_variant: {
        type: 'object',
        properties: {
          chromosome: { type: 'string', pattern: '^chr([1-9]|1[0-9]|2[0-2]|X|Y)$' },
          position: { type: 'number', minimum: 1 },
          ref: { type: 'string', pattern: '^[ATGCatgc]+$' },
          alt: { type: 'string', pattern: '^[ATGCatgc]+$' },
        },
        required: ['chromosome', 'position', 'ref', 'alt'],
      },
    },
    required: ['protective_variant', 'risk_variant'],
  },
};

export const BATCH_PATHOGENICITY_FILTER_TOOL: Tool = {
  name: 'batch_pathogenicity_filter',
  description: `Filter variants by pathogenicity threshold.

Efficiently identifies pathogenic variants from large lists.

Perfect for: VCF filtering, prioritizing clinical variants.

Example: "Filter 100 variants for pathogenicity > 0.7"`,
  inputSchema: {
    type: 'object',
    properties: {
      variants: {
        type: 'array',
        items: {
          type: 'object',
          properties: {
            chromosome: { type: 'string' },
            position: { type: 'number' },
            ref: { type: 'string' },
            alt: { type: 'string' },
          },
          required: ['chromosome', 'position', 'ref', 'alt'],
        },
        minItems: 1,
      },
      threshold: {
        type: 'number',
        minimum: 0,
        maximum: 1,
        description: 'Pathogenicity threshold (0-1, default: 0.5)',
      },
    },
    required: ['variants'],
  },
};

export const COMPARE_VARIANTS_SAME_GENE_TOOL: Tool = {
  name: 'compare_variants_same_gene',
  description: `Compare multiple variants within the same gene.

Ranks variants by impact within a single gene context.

Perfect for: gene-level analysis, compound heterozygote analysis.

Example: "Compare 5 BRCA1 variants"`,
  inputSchema: {
    type: 'object',
    properties: {
      variants: {
        type: 'array',
        items: {
          type: 'object',
          properties: {
            chromosome: { type: 'string' },
            position: { type: 'number' },
            ref: { type: 'string' },
            alt: { type: 'string' },
          },
          required: ['chromosome', 'position', 'ref', 'alt'],
        },
        minItems: 2,
      },
      gene_name: {
        type: 'string',
        description: 'Optional: gene name for context',
      },
    },
    required: ['variants'],
  },
};

export const PREDICT_ALLELE_SPECIFIC_EFFECTS_TOOL: Tool = {
  name: 'predict_allele_specific_effects',
  description: `Analyze allele-specific regulatory effects.

Detailed analysis of how each allele affects gene regulation differently.

Perfect for: ASE analysis, imprinting studies.

Example: "Analyze allele-specific effects of chr15:67890123A>G"`,
  inputSchema: {
    type: 'object',
    properties: {
      chromosome: { type: 'string', pattern: '^chr([1-9]|1[0-9]|2[0-2]|X|Y)$' },
      position: { type: 'number', minimum: 1 },
      ref: { type: 'string', pattern: '^[ATGCatgc]+$' },
      alt: { type: 'string', pattern: '^[ATGCatgc]+$' },
      tissue_type: { type: 'string' },
    },
    required: ['chromosome', 'position', 'ref', 'alt'],
  },
};

export const ANNOTATE_REGULATORY_CONTEXT_TOOL: Tool = {
  name: 'annotate_regulatory_context',
  description: `Provide comprehensive regulatory annotation for a variant.

Returns detailed regulatory context including all modalities.

Perfect for: variant annotation pipelines, comprehensive reports.

Example: "Annotate regulatory context of chr7:12345678C>A"`,
  inputSchema: {
    type: 'object',
    properties: {
      chromosome: { type: 'string', pattern: '^chr([1-9]|1[0-9]|2[0-2]|X|Y)$' },
      position: { type: 'number', minimum: 1 },
      ref: { type: 'string', pattern: '^[ATGCatgc]+$' },
      alt: { type: 'string', pattern: '^[ATGCatgc]+$' },
      tissue_type: { type: 'string' },
    },
    required: ['chromosome', 'position', 'ref', 'alt'],
  },
};

export const BATCH_MODALITY_SCREEN_TOOL: Tool = {
  name: 'batch_modality_screen',
  description: `Screen variants across specific regulatory modalities.

Efficiently tests multiple variants for specific regulatory effects.

Perfect for: targeted regulatory screens, modality-specific studies.

Example: "Screen 20 variants for splicing effects"`,
  inputSchema: {
    type: 'object',
    properties: {
      variants: {
        type: 'array',
        items: {
          type: 'object',
          properties: {
            chromosome: { type: 'string' },
            position: { type: 'number' },
            ref: { type: 'string' },
            alt: { type: 'string' },
          },
          required: ['chromosome', 'position', 'ref', 'alt'],
        },
        minItems: 1,
      },
      modality: {
        type: 'string',
        enum: ['expression', 'splicing', 'tf_binding', 'chromatin'],
        description: 'Regulatory modality to screen',
      },
    },
    required: ['variants', 'modality'],
  },
};

export const GENERATE_VARIANT_REPORT_TOOL: Tool = {
  name: 'generate_variant_report',
  description: `Generate comprehensive clinical report for a variant.

Full analysis with all modalities and clinical interpretation.

Perfect for: clinical reports, diagnostic summaries.

Example: "Generate full report for chr13:32912345G>T"`,
  inputSchema: {
    type: 'object',
    properties: {
      chromosome: { type: 'string', pattern: '^chr([1-9]|1[0-9]|2[0-2]|X|Y)$' },
      position: { type: 'number', minimum: 1 },
      ref: { type: 'string', pattern: '^[ATGCatgc]+$' },
      alt: { type: 'string', pattern: '^[ATGCatgc]+$' },
      tissue_type: { type: 'string' },
    },
    required: ['chromosome', 'position', 'ref', 'alt'],
  },
};

export const EXPLAIN_VARIANT_IMPACT_TOOL: Tool = {
  name: 'explain_variant_impact',
  description: `Provide human-readable explanation of variant impact.

Translates technical predictions into plain language.

Perfect for: patient reports, non-technical summaries.

Example: "Explain the impact of chr9:12345678A>C in simple terms"`,
  inputSchema: {
    type: 'object',
    properties: {
      chromosome: { type: 'string', pattern: '^chr([1-9]|1[0-9]|2[0-2]|X|Y)$' },
      position: { type: 'number', minimum: 1 },
      ref: { type: 'string', pattern: '^[ATGCatgc]+$' },
      alt: { type: 'string', pattern: '^[ATGCatgc]+$' },
      tissue_type: { type: 'string' },
    },
    required: ['chromosome', 'position', 'ref', 'alt'],
  },
};

/**
 * All available tools
 */
export const ALL_TOOLS: Tool[] = [
  PREDICT_VARIANT_TOOL,
  BATCH_SCORE_TOOL,
  ASSESS_PATHOGENICITY_TOOL,
  PREDICT_TISSUE_SPECIFIC_TOOL,
  COMPARE_VARIANTS_TOOL,
  PREDICT_SPLICE_IMPACT_TOOL,
  PREDICT_EXPRESSION_IMPACT_TOOL,
  ANALYZE_GWAS_LOCUS_TOOL,
  COMPARE_ALLELES_TOOL,
  BATCH_TISSUE_COMPARISON_TOOL,
  • scripts/alphagenome_bridge.py:818-819 (handler)
    Python bridge dispatch: routes 'batch_tissue_comparison' action to the handler function.
    elif action == 'batch_tissue_comparison':
    result = batch_tissue_comparison(client, params)
  • src/alphagenome-client.ts:340-346 (helper)
    TypeScript client bridge method: forwards batch_tissue_comparison params to Python bridge via callPythonBridge.
    async batchTissueComparison(params: any): Promise<any> {
  try {
    return await this.callPythonBridge('batch_tissue_comparison', params);
  } catch (error) {
    if (error instanceof ApiError) throw error;
    throw new ApiError(`Batch tissue comparison failed: ${error}`, 500);
  }

Tool Definition Quality

B3/5.0
Behavior2/5

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

No annotations are provided, so the description carries the full burden. It mentions 'efficient batch analysis' and an example, but doesn't disclose critical behavioral traits: whether this is a read-only or mutation operation, what permissions or authentication might be needed, rate limits, what the output looks like, or any side effects. For a tool with no annotations, this leaves significant gaps in understanding its behavior.

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

Conciseness5/5

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

The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by efficiency note, usage context, and an example. Each sentence adds value without redundancy, making it easy to scan and understand quickly.

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 no annotations, 0% schema description coverage, no output schema, and 2 parameters with complex nested objects (variants), the description is incomplete. It lacks details on behavioral traits, parameter semantics, output format, and how it differs from siblings. For a batch analysis tool in a domain with many similar tools, this leaves too many gaps for effective use.

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

Parameters2/5

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

Schema description coverage is 0%, so the description must compensate. It mentions 'variants' and 'tissues' but doesn't explain their semantics beyond the example. The schema shows 'variants' as an array of objects with chromosome, position, ref, alt, and 'tissues' as an array of strings, but the description adds minimal meaning (e.g., no details on tissue format or variant requirements). This falls short given the low coverage.

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

Purpose4/5

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

The description clearly states the tool's purpose: 'Analyze multiple variants across multiple tissues' and 'Efficient batch analysis of variants × tissues combinations.' This specifies both the action (analyze) and resources (variants, tissues) with the batch context. However, it doesn't explicitly differentiate from sibling tools like 'predict_tissue_specific' or 'compare_variants,' which prevents a perfect score.

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

Usage Guidelines3/5

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

The description provides some usage context: 'Perfect for: large-scale tissue-specificity studies' and includes an example. This implies when to use it (for batch analysis in tissue studies) but doesn't explicitly state when not to use it or name alternatives among the many sibling tools, such as when to choose this over 'predict_tissue_specific' or 'compare_variants.'

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/taehojo/alphagenome-mcp'

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