AlphaGenome MCP Server

Instructions

Implementation Reference

• src/index.ts:146-152 (handler)

  MCP server request handler for the 'assess_pathogenicity' tool. Validates input using variantPredictionSchema, calls the AlphaGenomeClient.assessPathogenicity method, and formats the result as MCP content.

  case 'assess_pathogenicity': {
    const params = validateInput(variantPredictionSchema, args) as VariantPredictionParams;
    const result = await getClient().assessPathogenicity(params);
    return {
      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
    };
  }

• src/tools.ts:152-196 (schema)

  Tool schema definition including name, description, and input schema for validating parameters like chromosome, position, ref, alt, and optional tissue_type.

  export const ASSESS_PATHOGENICITY_TOOL: Tool = {
    name: 'assess_pathogenicity',
    description: `Comprehensive pathogenicity assessment of a genetic variant.
  
  Evaluates variant across all regulatory modalities and provides clinical classification.
  
  Returns:
  - Pathogenicity score (0-1 scale)
  - Clinical classification (pathogenic/likely_pathogenic/uncertain/likely_benign/benign)
  - Evidence breakdown (expression, splicing, TF binding impacts)
  
  Perfect for: clinical variant interpretation, pathogenicity prediction, diagnostic sequencing.
  
  Example: "Assess pathogenicity of chr19:44908684T>C"`,
    inputSchema: {
      type: 'object',
      properties: {
        chromosome: {
          type: 'string',
          description: 'Chromosome (chr1-chr22, chrX, chrY)',
          pattern: '^chr([1-9]|1[0-9]|2[0-2]|X|Y)$',
        },
        position: {
          type: 'number',
          description: 'Genomic position (1-based)',
          minimum: 1,
        },
        ref: {
          type: 'string',
          description: 'Reference allele',
          pattern: '^[ATGCatgc]+$',
        },
        alt: {
          type: 'string',
          description: 'Alternate allele',
          pattern: '^[ATGCatgc]+$',
        },
        tissue_type: {
          type: 'string',
          description: 'Optional: disease-relevant tissue (default: brain)',
        },
      },
      required: ['chromosome', 'position', 'ref', 'alt'],
    },
  };

• src/tools.ts:709-730 (registration)

  Registration of the assess_pathogenicity tool by including ASSESS_PATHOGENICITY_TOOL in the ALL_TOOLS array, which is returned by the MCP listTools handler.

  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,
    PREDICT_TF_BINDING_IMPACT_TOOL,
    PREDICT_CHROMATIN_IMPACT_TOOL,
    COMPARE_PROTECTIVE_RISK_TOOL,
    BATCH_PATHOGENICITY_FILTER_TOOL,
    COMPARE_VARIANTS_SAME_GENE_TOOL,
    PREDICT_ALLELE_SPECIFIC_EFFECTS_TOOL,
    ANNOTATE_REGULATORY_CONTEXT_TOOL,
    BATCH_MODALITY_SCREEN_TOOL,
    GENERATE_VARIANT_REPORT_TOOL,
    EXPLAIN_VARIANT_IMPACT_TOOL,
  ];

• src/alphagenome-client.ts:238-251 (helper)

  AlphaGenomeClient method that handles the assess_pathogenicity action by calling the Python bridge script with formatted parameters.

  async assessPathogenicity(params: VariantPredictionParams): Promise<any> {
    try {
      return await this.callPythonBridge('assess_pathogenicity', {
        chromosome: params.chromosome,
        position: params.position,
        ref: params.ref,
        alt: params.alt,
        tissue_type: params.tissue_type,
      });
    } catch (error) {
      if (error instanceof ApiError) throw error;
      throw new ApiError(`Pathogenicity assessment failed: ${error}`, 500);
    }
  }

• scripts/alphagenome_bridge.py:255-296 (handler)

  Core implementation of pathogenicity assessment in the Python bridge. Computes a weighted pathogenicity score from expression, splicing, and TF binding impacts, and assigns ACMG-style clinical classification.

  def assess_pathogenicity(client, params: Dict[str, Any]) -> Dict[str, Any]:
      """
      Comprehensive pathogenicity assessment of a variant.
      Uses all modalities to provide clinical interpretation.
      """
      result = predict_variant_effect(client, params)
  
      # Calculate pathogenicity score based on multiple factors
      predictions = result['predictions']
  
      # Score components
      expression_impact = abs(predictions.get('rna_seq', {}).get('fold_change', 0))
      splice_impact = abs(predictions.get('splice', {}).get('delta', 0))
      tf_impact = max([tf.get('change', 0) for tf in predictions.get('tf_binding', [])], default=0)
  
      # Combined pathogenicity score (0-1 scale)
      pathogenicity_score = min(1.0, (expression_impact * 0.4 + splice_impact * 0.4 + tf_impact * 0.2))
  
      # Clinical classification
      if pathogenicity_score > 0.7:
          classification = 'pathogenic'
      elif pathogenicity_score > 0.4:
          classification = 'likely_pathogenic'
      elif pathogenicity_score > 0.2:
          classification = 'uncertain_significance'
      elif pathogenicity_score > 0.1:
          classification = 'likely_benign'
      else:
          classification = 'benign'
  
      return {
          'variant': result['variant'],
          'pathogenicity_score': float(pathogenicity_score),
          'classification': classification,
          'evidence': {
              'expression_impact': float(expression_impact),
              'splice_impact': float(splice_impact),
              'tf_binding_impact': float(tf_impact)
          },
          'predictions': predictions
      }