AlphaGenome MCP Server

Instructions

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);
    }