This server lets Claude agents analyze genetic variants with AlphaGenome, answering single-nucleotide variants instantly from the precomputed Atlas or running live model inference for indels and other variants.
Score one variant's regulatory effects per modality (expression, CAGE, chromatin, histone marks, TF binding, splicing) with scores, calibrated quantiles, and tissue/cell context
Batch-score and rank up to 100 variants, automatically routing each to the Atlas or live inference and reporting the source mix
Scan a genomic region (up to 10,000 bp, or 50,000 bp with opt-in) to rank every substitution without running the model
Look up one or many single-nucleotide variants in the Atlas with default or custom scorers
Report the AlphaGenome Variant Impact (AVI) score plus its 18-feature attributions for SNVs from the Atlas
Assess predicted effect size across modalities (name kept for compatibility; never classifies as pathogenic/benign)
Filter variants by an absolute-quantile threshold (default 0.99) as an effect-size filter
Generate fuller research reports and plain-language explanations of a variant's predicted effects
Predict splice impact, expression impact, TF binding impact, chromatin impact, and allele-specific effects
Compare two variants, protective-vs-risk-labelled variants, alternate alleles at one position, or variants affecting the same gene
Analyze GWAS loci, screen a batch within one modality, compare variants across tissues, or run tissue-specific predictions
List the Atlas scorers (names, track counts, assays) to pass into other tools
Enforce input validation (chromosomes chr1-22/X/Y, 1-based hg38 positions, A/T/G/C alleles, UBERON terms) and cap responses at top_n rows and 40,000 characters
Always state the answer's source (atlas, live, or live (atlas fallback)), returning only scores and quantiles94never a clinical classification.
Provides natural language access to Google DeepMind's AlphaGenome variant effect prediction API for analyzing genomic variants, assessing pathogenicity, predicting tissue-specific effects, and evaluating regulatory impacts across 11 molecular modalities including RNA-seq, ChIP-seq, ATAC-seq, and splicing.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@AlphaGenome MCP Server analyze the pathogenicity of rs429358 in brain tissue"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
AlphaGenome as a tool for Claude agents. A Model Context Protocol (MCP) server that lets an agent turn a researcher's question into an AlphaGenome analysis.
Ninety seconds in Claude Code, shown at 2x speed, with the published package and the real API. The video has no sound; pause it to read an answer.
https://github.com/user-attachments/assets/cbd083ee-53f9-4b35-b11e-3b33e10f7df9
Time | Prompt | What happens |
0:08 |
| A single-nucleotide variant: answered from the Atlas, with the AVI score |
0:36 |
| The Atlas cannot hold an indel: live inference, and the result says so. A live result has no AVI score |
1:05 |
| 6,003 substitutions ranked from the Atlas without running the model |
The explanations in the video are written by Claude from the tool results. The tools themselves return scores and calibrated quantiles, and never a pathogenicity call.
Related MCP server: EVEE MCP Server
A researcher asks a question; the agent decides which AlphaGenome calls answer it, runs them, and reads the results back. This server gives the agent the two ways AlphaGenome can be asked:
The AlphaGenome Atlas for single-nucleotide variants. The Atlas holds precomputed predictions for every possible single-nucleotide substitution in the human genome, so a lookup answers in seconds and a whole region can be ranked without running the model.
Live inference for indels and other variants the Atlas cannot precompute.
The server chooses between the two automatically, and every result states its source (source: atlas or source: live), so a precomputed score is never mistaken for a fresh model call or the other way round.
Key Features:
Atlas first: single-nucleotide variants are answered from the precomputed Atlas; live inference runs only when it is needed
Always says where the answer came from: source: atlas, source: live, or source: live (atlas fallback: <reason>)
One shape for both sources: live inference uses the SDK's score_variant with its recommended variant scorers, which have the same names as the Atlas scorers, so an Atlas result and a live result can be read side by side
AVI score and its attributions: the AlphaGenome Variant Impact score (AVI_SCORE) and its feature attributions are first-class outputs for single-nucleotide variants
Region scans without the model: rank every substitution in a region by the AVI score
24 tools: 4 Atlas tools and 20 variant tools
These are model predictions for research prioritization, not clinical classifications. Every tool reports AlphaGenome's scores and calibrated quantiles as returned. No tool classifies a variant as pathogenic or benign, assigns a risk label, or states a percent change, on either path. Not for diagnosis or treatment decisions.
Get started in 3 minutes:
Get an API key at https://deepmind.google.com/science/alphagenome (free for non-commercial use). You need Node.js 18+ and Python 3.10+.
Install dependencies
pip install alphagenome numpyIf this fails, or you are on Windows, use a virtual environment: see Python environment.
Add to your MCP client (supports Claude Code, Claude Desktop, Gemini CLI, Cursor, Windsurf)
claude mcp add alphagenome --env ALPHAGENOME_API_KEY=YOUR_API_KEY -- npx -y @jolab/alphagenome-mcp@latestSee Installation for other MCP clients.
Run your first query
Restart your MCP client and try:
"Use alphagenome to analyze chr19:44908684T>C"View results
This is a single-nucleotide variant, so it is answered from the Atlas in a few seconds and the report starts with Source: atlas. An indel would run live inference instead (typically 3-10 seconds) and say Source: live.
Want more? Check out the 24 tools below.
AlphaGenome MCP Server implements a multi-tier architecture:
┌─────────────────────────┐
│ Researcher │
└───────────┬─────────────┘
│ Natural language query
↓
┌─────────────────────────┐
│ Claude Desktop │ ← MCP Client
└───────────┬─────────────┘
│ JSON-RPC over stdio
↓
┌─────────────────────────┐
│ MCP Server (TypeScript)│ ← Tool routing, validation
└───────────┬─────────────┘
│ subprocess
↓
┌─────────────────────────┐
│ Python Bridge │ ← Interface to AlphaGenome SDK
└───────────┬─────────────┘
│ HTTP
↓
┌─────────────────────────┐
│ AlphaGenome API │ ← Google DeepMind's service
└─────────────────────────┘AlphaGenome Atlas | Live inference | |
What it answers | Single-nucleotide substitutions on hg38 (chr1-22, chrX, chrY) | Any single variant: single-nucleotide, indel, multi-nucleotide |
How | Looks up precomputed scores | Runs the AlphaGenome model |
Typical time | 2-5 seconds per variant, about 7 seconds for a 2,000 bp region | 3-10 seconds per variant |
Six tools choose between the two on their own: predict_variant_effect, batch_score_variants, assess_pathogenicity, batch_pathogenicity_filter, generate_variant_report and explain_variant_impact. They take an optional source parameter:
| Behaviour |
| Atlas when |
| Atlas only. Never falls back; a variant the Atlas cannot answer is an error |
| Always runs the model |
The fallback is deliberately narrow. It happens only when the Atlas reports that it does not hold the variant. Authentication, rate limit, network and timeout errors are returned as errors, and so is a variant the Atlas rejects: if the reference base does not match hg38, the Atlas says which base it expected, and the server passes that message on instead of running the model on a mistyped variant. In a batch, each variant is routed on its own and the result reports how many came from each source and how many fell back. A mixed batch is reported as two separately ranked groups: the Atlas group is ranked by the AVI score by default, live inference has no AVI score, so one merged ranking would compare different quantities.
Every tool is a view over two primitives: score one variant and score many variants and rank them. Each is answered by the Atlas or by live inference, and both return the same thing: for each scorer, a matrix of rows (the variant, or one row per gene or junction) by tracks (tissues, cell types, assays), with a calibrated quantile for every score.
Atlas client.query_variant(variant, requested_scorers=[...])
Live inference client.score_variant(interval, variant, RECOMMENDED_VARIANT_SCORERS[...])
-> {scorer: AnnData} -> one shared summarizer -> ranked rows + sourceThe scorer names are the same on both sides (RNA_SEQ, CAGE, DNASE, CHIP_HISTONE, CHIP_TF, SPLICE_SITES, ...). The AVI scorers are the exception: the Atlas alone serves them. For chr17:49210289 C>T the two sources agree on the strongest track of five of the six default scorers, with scores that are close but not identical (DNASE in HeLa-S3: 2.778 from the Atlas, 2.846 live; CAGE in HeLa-S3: 1.866 and 2.121).
A matrix is never returned. One variant is thousands of numbers per scorer, so every result is the strongest cells, ranked, with the gene, tissue and assay of each.
All inputs undergo validation before API submission:
Chromosomes: Pattern-matched for chr1-22, chrX, chrY
Positions: Validated as positive integers
Alleles: A/T/G/C nucleotide validation
Tissue types: UBERON ontology term validation
Invalid inputs return human-readable error messages, enabling conversational error recovery.
Precomputed scores, no model call. Every Atlas response is a summary: ranked rows, never a full score matrix. One variant alone is thousands of numbers per scorer (61 genes x 371 tracks for RNA-seq at the APOE locus), so responses are capped at top_n rows (default 25, maximum 100) and at 40,000 characters.
The scorers the Atlas serves (22 at the time of writing), with the number of tracks and the assays behind each. Cached for the session.
"Which scorers does the AlphaGenome Atlas have?"Scores of one single-nucleotide variant: the strongest tracks per scorer, ranked by absolute score, with the gene, tissue or cell type, and assay of each.
"Look up chr19:44908684 T>C in the AlphaGenome Atlas"Up to 500 single-nucleotide variants in one call, ranked by absolute score. Variants the Atlas does not hold, and variants it rejects (for example a reference base that does not match hg38), are listed separately with the reason instead of failing the whole call.
"Rank these 200 GWAS SNPs by their Atlas scores"Every possible single-nucleotide substitution in a region, ranked by absolute score. Answers "which positions in this region matter most?" without running the model. At most 10,000 bp; up to 50,000 bp only with allow_large_region: true.
"Scan chr17:49209289-49211289 and show the 10 substitutions with the largest predicted effect"Default scorers. Override with the scorers parameter; names come from atlas_list_scorers.
Used for | Default | Why |
One variant ( |
| One representative scorer per modality: overall impact, expression, transcription start, accessibility, histone marks, TF binding, splicing |
Many variants and regions ( |
| One number per variant makes the ranking meaningful and keeps the call inside the API's request quota. Measured on a 2,000 bp scan: |
For batch_score_variants, the scoring_metric picks the Atlas scorer when scorers is not given: rna_seq uses RNA_SEQ, splice uses SPLICE_SITES, regulatory_impact and combined use AVI_SCORE.
The AVI score. The AlphaGenome Variant Impact (AVI) score combines AlphaGenome's predictions with AlphaMissense and other features into one number per variant. The Atlas serves it through the API as three scorers, and this server treats them as first-class outputs:
Scorer | What it is |
| The score itself, one value per variant, with its calibrated quantile. The default for ranking many variants and for region scans |
| The contribution of each of the 18 features to the score ( |
| The values of those 18 features |
The AVI score exists for single-nucleotide variants only, because only the Atlas serves it. A live result has no AVI score, and says so rather than approximating one. Scores and quantiles are reported exactly as returned; they are not turned into a pathogenic or benign call.
Limits to know about.
The Atlas API has a requests-per-minute quota, and a region scan uses one request per 32 bp. That is why a scan is limited to 10,000 bp unless allow_large_region is set. Long scans wait and retry when the quota is hit. If the time limit (ALPHAGENOME_TIMEOUT_MS) is reached first, the partial result is returned, marked Incomplete, with the range that was really scanned; it is never silently truncated.
Scorers with one row per gene or junction (RNA_SEQ, SPLICE_JUNCTIONS, ...) return more data per request than the API allows for a region scan. Scan with AVI_SCORE first, then look up the top variants with atlas_lookup_variant.
Human reference genome (hg38) only. Positions are 1-based.
All six take source (auto, atlas, live) and scorers.
The strongest tracks of each modality for one variant, with score, quantile, gene, tissue and assay. From the Atlas the AVI score is included. Optional output_types and tissue_type.
"Use alphagenome to analyze chr19:44908684T>C"Up to 100 variants, each routed on its own, ranked by predicted effect. Reports how many came from each source and how many fell back.
"Use alphagenome to score these 50 variants and show the top 10"Predicted effect size across modalities, and the AVI score from the Atlas. The name is kept for compatibility: it does not classify. classification is always null.
"Use alphagenome to assess rs429358"Keeps the variants whose largest absolute quantile reaches threshold (default 0.99), ranked, per source. A filter on predicted effect size, not on pathogenicity.
"Use alphagenome to keep the variants above the 99.9th percentile"A fuller report of one variant: more rows per scorer and, from the Atlas, the AVI score with its feature attributions. A research summary, not a clinical report: no classification, no recommendation.
"Use alphagenome to generate a report for rs429358"Plain sentences that restate the numbers: the AVI score and its largest contributions, then the strongest effect of each modality ordered by quantile, with the direction for signed scorers. Descriptive only.
"Use alphagenome to explain the predicted effect of rs429358"These run score_variant and work for single-nucleotide variants, indels and multi-nucleotide variants. Every result states source: live. Tools that take one variant accept an optional tissue_type (a name such as brain, or an ontology CURIE such as UBERON:0000955).
Tool | What it returns |
| Splice sites, splice site usage and splice junctions, with the gene and junction of each |
| RNA-seq (log fold change per gene and tissue) and CAGE |
| TF ChIP-seq, with the factor and cell type of each track |
| ATAC-seq and DNase-seq |
| Alternate against reference allele: |
| Every regulatory modality at once, to see where the predicted effect concentrates |
| The strongest effect of each scorer within each of several tissues |
| Two variants side by side, and which has the larger quantile per scorer |
| The same comparison with the caller's labels; the tool does not judge which allele is protective |
| The alternate alleles of one position, ranked |
| The variants of a locus, ranked |
| Variants ranked by their effect on one gene ( |
| Variants ranked within one modality: |
| One ranking per tissue |
Rankings over several scorers use the largest absolute quantile, because quantiles are calibrated and the raw scores of different scorers are not on one scale. A ranking over one scorer uses its absolute score.
Node.js ≥18.0.0
Python ≥3.10 (required by the alphagenome package)
alphagenome ≥0.9.0 for the Atlas tools
AlphaGenome API key: https://deepmind.google.com/science/alphagenome (free for non-commercial use)
Python packages: alphagenome, numpy
Variable | Purpose |
| Your API key. Put it in the |
| Python interpreter to use, for example a virtualenv ( |
| Time allowed for one call, in milliseconds (default 180000). Raise it for large region scans and batches |
The server runs the AlphaGenome Python SDK in a subprocess, so it needs a Python 3.10+ interpreter that has alphagenome installed. A virtual environment is the reliable way to get one: it avoids the "externally managed environment" error of system Pythons on macOS and Linux, and on Windows, where python3 usually does not exist and python is often not on the PATH, it gives you a path to point at.
# macOS / Linux
python3 -m venv ~/.alphagenome-venv
~/.alphagenome-venv/bin/pip install alphagenome numpy# Windows (PowerShell)
py -3 -m venv $HOME\.alphagenome-venv
& $HOME\.alphagenome-venv\Scripts\pip install alphagenome numpyThen tell the server which interpreter to use with ALPHAGENOME_PYTHON:
claude mcp add alphagenome \
--env ALPHAGENOME_API_KEY=YOUR_API_KEY \
--env ALPHAGENOME_PYTHON=/Users/you/.alphagenome-venv/bin/python \
-- npx -y @jolab/alphagenome-mcp@latestIn a JSON configuration it goes in the same env block as the key (use the full path; on Windows, double the backslashes):
"env": {
"ALPHAGENOME_API_KEY": "YOUR_API_KEY",
"ALPHAGENOME_PYTHON": "C:\\Users\\you\\.alphagenome-venv\\Scripts\\python.exe"
}If alphagenome is installed for the python3 (or python) on your PATH, you can skip ALPHAGENOME_PYTHON.
1. Install Python dependencies (or use the virtual environment above):
pip install alphagenome numpy2. Configure for your MCP client:
claude mcp add alphagenome --env ALPHAGENOME_API_KEY=YOUR_API_KEY -- npx -y @jolab/alphagenome-mcp@latestThis writes the server to ~/.claude.json. Add --scope project to write it to .mcp.json in the current project instead.
Test:
"Use alphagenome to analyze chr19:44908684T>C"Add to claude_desktop_config.json:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"alphagenome": {
"command": "npx",
"args": ["-y", "@jolab/alphagenome-mcp@latest"],
"env": { "ALPHAGENOME_API_KEY": "YOUR_API_KEY" }
}
}
}Test:
"Use alphagenome to analyze chr19:44908684T>C"Add to ~/.gemini/settings.json:
{
"mcpServers": {
"alphagenome": {
"command": "npx",
"args": ["-y", "@jolab/alphagenome-mcp@latest"],
"env": { "ALPHAGENOME_API_KEY": "YOUR_API_KEY" }
}
}
}Test:
"Use alphagenome to analyze chr19:44908684T>C"Add to .cursor/mcp.json in your project root:
{
"mcpServers": {
"alphagenome": {
"command": "npx",
"args": ["-y", "@jolab/alphagenome-mcp@latest"],
"env": { "ALPHAGENOME_API_KEY": "YOUR_API_KEY" }
}
}
}Test:
"Use alphagenome to analyze chr19:44908684T>C"Add to your Windsurf settings JSON:
{
"mcpServers": {
"alphagenome": {
"command": "npx",
"args": ["-y", "@jolab/alphagenome-mcp@latest"],
"env": { "ALPHAGENOME_API_KEY": "YOUR_API_KEY" }
}
}
}Test:
"Use alphagenome to analyze chr19:44908684T>C"Check that the client can start the server. In Claude Code:
claude mcp listalphagenome: ... ✔ Connected means the server starts. It does not yet prove that Python and the key work; the first query does.
Restart your MCP client and ask:
"Use alphagenome to analyze chr19:44908684T>C"Expected: a report that starts with Source: atlas within a few seconds. An indel (for example chr17:49210289 CCC>C) says Source: live and typically takes 3-10 seconds.
The server reports problems as tool errors and keeps running. The message tells you which case you are in:
Message | Cause and fix |
| No Python on the PATH of the MCP client. Set |
| The interpreter in the message has no |
| Put |
| The key was rejected. Check for a truncated or expired key |
| The |
| The API's per-minute quota. Wait a minute; scan a smaller region |
| A large scan or batch. Raise |
|
|
Tip: say "use alphagenome" in a query when the client does not pick the server on its own.
All examples are actual results from the API (September 2026) for the two APOE variants that define the ε4 and ε2 alleles.
User: "Use alphagenome to assess rs429358" (chr19:44908684 T>C){
"source": "atlas",
"variant": "chr19:44908684:T>C",
"avi_score": { "score": 0.4999, "quantile": 0.9869896 },
"strongest_effects": [
{ "scorer": "RNA_SEQ", "score": -0.038891, "quantile": -0.9996803, "where": "APOE, psoas muscle, polyA plus RNA-seq" },
{ "scorer": "CAGE", "score": 0.077866, "quantile": 0.9774153, "where": "pons, hCAGE" },
{ "scorer": "DNASE", "score": 0.12269, "quantile": 0.9463574, "where": "brain, DNase-seq" },
{ "scorer": "CHIP_HISTONE", "score": 0.13507, "quantile": 0.9953638, "where": "H3K27me3, common myeloid progenitor, CD34-positive, Histone ChIP-seq" },
{ "scorer": "CHIP_TF", "score": -0.16594, "quantile": -0.9972084, "where": "MYC, K562, TF ChIP-seq" },
{ "scorer": "SPLICE_SITES", "score": 0.022699, "quantile": 0.9561927, "where": "APOE" }
],
"largest_abs_quantile": 0.9996803,
"classification": null
}User: "Use alphagenome to explain the predicted effect of rs429358"AlphaGenome Variant Impact (AVI) score: 0.4999 (quantile 0.9869896).
Largest contributions to the AVI score: CACTUS_241_WAY (0.2944), PHASTCONS_470_WAY (0.14471), ALPHAMISSENSE (0.029138).
RNA_SEQ: largest predicted effect in APOE, psoas muscle, polyA plus RNA-seq, score -0.038891, quantile -0.9996803 (negative: predicted lower with the alternate allele than the reference).
CHIP_TF: largest predicted effect in MYC, K562, TF ChIP-seq, score -0.16594, quantile -0.9972084 (negative: ...).
...User: "Use alphagenome to analyze the deletion chr17:49210289 CCC>C"**Variant**: chr17:49210289:CCC>C
**Source**: live
**Note**: Live inference because: deletion (CCC>C); the Atlas covers single-nucleotide substitutions only.
## RNA_SEQ
61 row(s) x 371 track(s); largest absolute score 0.8843, median 9.28e-4.
| Score | Quantile | Where |
|---|---|---|
| -0.8843 | -0.9999997 | ABI3, cardiac atrium fibroblast, total RNA-seq |chr17:49210289 C>T with source: atlas and with source: live, strongest track per scorer:
Scorer | Atlas: score (quantile), where | Live: score (quantile), where |
RNA_SEQ | 0.8612 (0.9999993), ABI3, LHCN-M2 | 0.9677 (0.9999996), ABI3, HFFc6 |
CAGE | 1.866 (0.9999712), HeLa-S3 | 2.121 (0.9999838), HeLa-S3 |
DNASE | 2.778 (0.9998919), HeLa-S3 | 2.846 (0.9999024), HeLa-S3 |
CHIP_HISTONE | 1.846 (0.9999757), H3K27ac, HeLa-S3 | 1.967 (0.9999808), H3K27ac, HeLa-S3 |
CHIP_TF | 1.675 (0.9999024), POLR2A, HeLa-S3 | 1.785 (0.9999371), POLR2A, HeLa-S3 |
SPLICE_SITES | 0.06445 (0.9875146), GNGT2 | 0.04785 (0.9813679), GNGT2 |
The numbers are close, not identical: the Atlas was computed ahead of time and the live call runs the model now.
User: "Use alphagenome to compare APOE rs429358 and rs7412"{
"source": "live",
"variants": [
{ "label": "variant1", "variant": "chr19:44908684:T>C",
"effects": [ { "scorer": "RNA_SEQ", "score": -0.037954, "quantile": -0.9996693, "where": "APOE, psoas muscle, polyA plus RNA-seq" }, "..." ] },
{ "label": "variant2", "variant": "chr19:44908822:C>T",
"effects": [ { "scorer": "RNA_SEQ", "score": 0.035793, "quantile": 0.9997013, "where": "APOE, endothelial cell of umbilical vein, polyA plus RNA-seq" }, "..." ] }
],
"larger_abs_quantile_by_scorer": { "RNA_SEQ": "variant2", "...": "..." }
}User: "Use alphagenome to compare rs429358 in brain and liver"In brain the strongest RNA-seq effect is on APOE (score -0.0084, quantile -0.9943216); DNase-seq in brain is 0.1224 (quantile 0.9463574) and in liver -0.004807 (quantile -0.1842174).
User: "Use alphagenome to keep the variants above the 99th percentile: rs429358, rs7412, and the deletion chr17:49210289 CCC>C"The two SNVs are answered from the Atlas and ranked by the AVI score (rs7412: 0.8636, quantile 0.995461, kept; rs429358: quantile 0.9869896, not kept). The deletion is answered by live inference (largest quantile 0.9999997, kept). The result reports the two groups separately: "source": "mixed", "answered_from": { "atlas": 2, "live": 1, "atlas_fallback": 0 }.
Atlas: 2-5 seconds per variant, about 7 seconds for a 2,000 bp region scan (with AVI_SCORE)
Live inference: typically 3-10 seconds per variant (measured through the server, September 2026; depends on API load)
Modalities: 11 (RNA-seq, CAGE, PRO-cap, splice sites, DNase, ATAC, histone mods, TF binding, contact maps)
git clone https://github.com/taehojo/alphagenome-mcp.git
cd alphagenome-mcp
npm install
pip install -r requirements.txt
npm run buildsrc/
├── index.ts # MCP server entry point
├── alphagenome-client.ts # API client (Python bridge, timeout, interpreter choice)
├── routing.ts # Atlas or live inference: the rule, as pure functions
├── variant-tools.ts # The 20 variant tools, over two primitives and a narrow backend interface
├── tools.ts # MCP tool definitions
├── types.ts # TypeScript type definitions
├── tests/ # Unit tests (no API key needed)
└── utils/
├── config.ts # Environment variables
├── validation.ts # Input validation (Zod schemas)
└── formatting.ts # One set of formatters for both sources, and the size cap
scripts/
├── alphagenome_bridge.py # Bridge: one JSON request in, one JSON response out
├── atlas_actions.py # Atlas lookups and region scans
├── live_actions.py # Live inference with score_variant
├── summaries.py # The summarizer shared by both sources (numpy only)
└── tests/ # Python unit tests for the summarizernpm test # Build, then run the TypeScript unit tests (no API key needed)
npm run test:python # Python unit tests for the shared summarizer (numpy and pandas only)
npm run docs:api # Regenerate docs/API.md from the tool definitions in src/tools.ts
npm run lint # ESLint check
npm run typecheck # TypeScript type checking
npm run build # Compile to build/Not in this release, and not promised by any tool above:
Combinations of variants: scoring several variants together on one haplotype, rather than one at a time.
Custom sequences: predictions for a sequence the caller supplies, rather than a variant on the reference genome.
Both need live inference and neither can be precomputed, so they fit the same design: the Atlas where it can answer, the model where it cannot, and the source on every result.
From a microglia gene to a variant map in about 60 seconds. The research workflow this server came from: which non-coding variants near ABI3 change its expression, answered with a traditional pipeline and with one sentence in Claude Code. Click the image for full resolution.
Rare variants and AlphaGenome-predicted regulatory impact in 85 Alzheimer's disease genes: an interactive browser of the rare variants (MAF < 1%) in 85 AD-associated genes from ADSP whole-genome sequencing, scored with AlphaGenome across eight regulatory modalities and compared with case-control allele frequencies in 24,595 ADSP R4 participants, with an independent assessment in 11,545 ADSP R5 participants (Jo et al., manuscript under review). Code and the 9,943-variant analysis table: taehojo/rarevariants.
The scores in that study were computed with the AlphaGenome Python SDK directly, not with this server, and before its 0.3.0 scoring. They are not output of this server.
If you use this software in your research, please cite:
@software{jo2025alphagenome_mcp,
author = {Jo, Taeho},
title = {AlphaGenome MCP Server},
year = {2025},
url = {https://github.com/taehojo/alphagenome-mcp},
version = {0.2.0}
}AlphaGenome model:
@article{avsec2026alphagenome,
title = {Advancing regulatory variant effect prediction with {AlphaGenome}},
author = {Avsec, Žiga and Latysheva, Natasha and Cheng, Jun and others},
journal = {Nature},
volume = {649},
number = {8099},
pages = {1206--1218},
year = {2026},
doi = {10.1038/s41586-025-10014-0}
}Google DeepMind for developing and providing access to the AlphaGenome API
Anthropic for developing the Model Context Protocol specification and Claude Desktop
MIT License - Copyright (c) 2025 Taeho Jo
See LICENSE file for details.
npm Package: https://www.npmjs.com/package/@jolab/alphagenome-mcp
GitHub Repository: https://github.com/taehojo/alphagenome-mcp
AlphaGenome: https://deepmind.google/discover/blog/alphagenome/
Model Context Protocol: https://modelcontextprotocol.io/
Claude Desktop: https://claude.ai/download
Rank the variants of a locus by predicted effect (largest absolute quantile across modalities), to prioritize candidates for follow-up. For single-nucleotide variants only, atlas_lookup_variants or atlas_scan_region is faster and adds the AVI score.
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Inputs: variants (required), end, start, chromosome.
The predicted effects of a variant across every regulatory modality at once: accessibility, histone marks, TF binding, CAGE, RNA-seq, splice sites, polyadenylation and contact maps. Shows where the predicted effect concentrates; it does not label the variant.
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Inputs: alt (required), ref (required), position (required), chromosome (required), +1 more.
Predicted effect size of a variant across modalities, for prioritization. The tool name is kept for compatibility: it does NOT classify a variant as pathogenic or benign, and classification is always null.
Returns the strongest effect per scorer (score, calibrated quantile, where it was seen), the largest absolute quantile, and, for a single-nucleotide variant answered from the Atlas, the AlphaGenome Variant Impact (AVI) score. avi_score is null on the live path, because the AVI score is served by the Atlas only.
Source: a single-nucleotide variant is answered from the precomputed AlphaGenome Atlas; an indel or multi-nucleotide variant runs live inference (score_variant). Both return the same scorers in the same shape. Chosen automatically, overridable with source, and always stated in the result.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Example: "How large is the predicted effect of chr19:44908684 T>C?"
Inputs: alt (required), ref (required), position (required), chromosome (required), +3 more.
List the variant scorers available in the AlphaGenome Atlas, including the AlphaGenome Variant Impact score (AVI_SCORE) and its feature attributions (AVI_SCORE_FEATURE_IMPORTANCE, AVI_SCORE_MODEL_FEATURES).
Returns each scorer's name, number of tracks and the assays behind it. Use these names in the scorers parameter of the other tools. Every scorer except the AVI ones is also available from live inference under the same name. Cached for the session after the first call.
The Atlas holds precomputed AlphaGenome scores for single-nucleotide substitutions on the human reference genome (hg38, chr1-22, chrX, chrY). Indels and multi-nucleotide variants are not in it; use predict_variant_effect for those.
Inputs: no named parameters.
Look up the precomputed AlphaGenome scores of one single-nucleotide variant. No model call, so it answers in seconds.
Returns, per scorer, the strongest tracks for the variant ranked by absolute score, each with its calibrated quantile, gene, tissue or cell type, and assay. Default scorers: AVI_SCORE plus one per modality (RNA_SEQ, CAGE, DNASE, CHIP_HISTONE, CHIP_TF, SPLICE_SITES).
If the reference base does not match hg38, the Atlas says which base it expected and that message is returned as a validation error.
The Atlas holds precomputed AlphaGenome scores for single-nucleotide substitutions on the human reference genome (hg38, chr1-22, chrX, chrY). Indels and multi-nucleotide variants are not in it; use predict_variant_effect for those.
The response is a summary, never a full score matrix: ranked rows only, capped at top_n (default 25, max 100) and at 40,000 characters.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Example: "Look up chr19:44908684 T>C in the AlphaGenome Atlas"
Inputs: alt (required), ref (required), position (required), chromosome (required), +2 more.
Look up precomputed AlphaGenome scores for up to 500 single-nucleotide variants in one call and rank them.
Returns one row per variant (its strongest score and where it was seen), ranked. Default scorer: AVI_SCORE (AlphaGenome Variant Impact), one number per variant. With several scorers the ranking uses the largest absolute quantile. Variants the Atlas does not hold and variants it rejects (for example a reference base that does not match hg38) are listed separately with the reason; they do not fail the call.
The Atlas holds precomputed AlphaGenome scores for single-nucleotide substitutions on the human reference genome (hg38, chr1-22, chrX, chrY). Indels and multi-nucleotide variants are not in it; use predict_variant_effect for those.
The response is a summary, never a full score matrix: ranked rows only, capped at top_n (default 25, max 100) and at 40,000 characters.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Example: "Rank these 200 GWAS SNPs by their Atlas scores"
Inputs: variants (required), top_n, scorers.
Scan a genomic region in the AlphaGenome Atlas: every possible single-nucleotide substitution in the interval, ranked. Answers "which positions in this region matter most?" without running the model.
Region width: at most 10,000 bp. Up to 50,000 bp only with allow_large_region=true. A scan is one API request per 32 bp under a requests-per-minute quota, so a large scan can take minutes. If the quota or the time limit stops a scan early, the partial result is returned, marked "Incomplete", with the range that was really scanned; the ranking then covers that range only.
Default scorer: AVI_SCORE (about 7 seconds for 2,000 bp). Multi-track scorers are much slower (2,000 bp: DNASE 17 s, CHIP_TF 86 s). Scorers with one row per gene or junction (RNA_SEQ, SPLICE_JUNCTIONS, ...) cannot be used for a scan: scan with AVI_SCORE, then use atlas_lookup_variant on the top variants.
The Atlas holds precomputed AlphaGenome scores for single-nucleotide substitutions on the human reference genome (hg38, chr1-22, chrX, chrY). Indels and multi-nucleotide variants are not in it; use predict_variant_effect for those.
The response is a summary, never a full score matrix: ranked rows only, capped at top_n (default 25, max 100) and at 40,000 characters.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Example: "Scan chr17:49209289-49211289 and show the 10 substitutions with the largest predicted effect"
Inputs: end (required), start (required), chromosome (required), top_n, +2 more.
Rank several variants by predicted effect within one modality: expression (RNA_SEQ, CAGE), splicing (SPLICE_SITES, SPLICE_SITE_USAGE), tf_binding (CHIP_TF) or chromatin (DNASE, ATAC).
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Inputs: modality (required), variants (required).
Keep the variants whose predicted effect reaches a threshold, ranked. The tool name is kept for compatibility: it filters on predicted effect size, NOT on pathogenicity, and classifies nothing.
threshold is the smallest absolute calibrated quantile (0 to 1) a variant must reach to be kept (default 0.99): the AVI score's quantile for variants answered from the Atlas, the largest quantile across modalities for live inference. Variants are routed per variant and reported per source; groups from different sources are not comparable.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Example: "Which of these variants have a predicted effect above the 99.9th percentile?"
Inputs: variants (required), source, scorers, threshold.
Score up to 100 variants and rank them by predicted effect.
Each variant is routed on its own: single-nucleotide variants to the Atlas, the rest to live inference. A mixed batch comes back as two separately ranked groups, because the Atlas group is ranked by the AVI score and live inference has no AVI score; the two must not be compared. The result reports how many variants came from each source and how many fell back.
Scoring metric (used when scorers is not given): rna_seq = RNA_SEQ, splice = SPLICE_SITES, regulatory_impact and combined = AVI_SCORE from the Atlas and every modality (ranked by the largest absolute quantile) from live inference.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Example: "Score these 50 variants and show me the top 10 by predicted effect"
Inputs: variants (required), scoring_metric (required), top_n, source, +1 more.
Rank several variants by predicted effect within each of several tissues: one ranking per tissue.
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Inputs: tissues (required), variants (required).
Rank the alternate alleles of one position by predicted effect.
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Inputs: ref (required), alts (required), position (required), chromosome (required).
Two variants side by side, labelled as the caller names them. The tool compares predicted effect sizes per modality; it does not judge which allele is protective or a risk.
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Inputs: risk_variant (required), protective_variant (required).
Two variants side by side: the strongest predicted effect of each modality for both, and which of the two has the larger absolute quantile per scorer. A comparison of predicted effect sizes, not of severity.
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Example: "Compare APOE rs429358 and rs7412"
Inputs: variant1 (required), variant2 (required).
Rank several variants by their predicted effect on one gene. With gene_name, the gene-level scorers (RNA_SEQ, SPLICE_SITES) are restricted to that gene.
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Inputs: variants (required), gene_name.
Plain sentences that restate a variant's predicted effects: the AVI score and its largest contributions (from the Atlas), then the strongest effect of each modality ordered by absolute quantile, with the direction for signed scorers. Descriptive only: the sentences restate returned numbers and make no statement about pathogenicity.
Source: a single-nucleotide variant is answered from the precomputed AlphaGenome Atlas; an indel or multi-nucleotide variant runs live inference (score_variant). Both return the same scorers in the same shape. Chosen automatically, overridable with source, and always stated in the result.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Example: "Explain the predicted effect of chr17:49210289 C>T in plain language"
Inputs: alt (required), ref (required), position (required), chromosome (required), +3 more.
A fuller report of one variant's predicted molecular effects: more rows per scorer than predict_variant_effect and, from the Atlas, the AVI score with its feature attributions (AVI_SCORE_FEATURE_IMPORTANCE). It is a research summary, not a clinical report: it contains no pathogenicity classification and no recommendation.
Source: a single-nucleotide variant is answered from the precomputed AlphaGenome Atlas; an indel or multi-nucleotide variant runs live inference (score_variant). Both return the same scorers in the same shape. Chosen automatically, overridable with source, and always stated in the result.
The response is a summary, never a full score matrix: ranked rows only, capped at top_n (default 25, max 100) and at 40,000 characters.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Example: "Generate a report for chr19:44908684 T>C"
Inputs: alt (required), ref (required), position (required), chromosome (required), +3 more.
Predicted expression with the alternate allele against the reference allele: the RNA_SEQ scorer is that log fold change per gene and tissue, and RNA_SEQ_ACTIVE gives the expression level alongside it.
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Inputs: alt (required), ref (required), position (required), chromosome (required), +1 more.
Predicted chromatin accessibility effects of a variant (ATAC-seq and DNase-seq).
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Inputs: alt (required), ref (required), position (required), chromosome (required), +1 more.
Predicted gene expression effects of a variant: RNA-seq (log fold change per gene and tissue) and CAGE.
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Inputs: alt (required), ref (required), position (required), chromosome (required), +1 more.
Predicted splicing effects of a variant: splice sites, splice site usage and splice junctions, with the gene and junction of each.
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Inputs: alt (required), ref (required), position (required), chromosome (required), +1 more.
Predicted transcription factor binding effects of a variant (TF ChIP-seq), with the factor and cell type of each.
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Inputs: alt (required), ref (required), position (required), chromosome (required), +1 more.
The strongest predicted effect of a variant in each of several tissues: the same scores, filtered to the tracks of one tissue at a time.
Runs live inference (score_variant with the SDK's recommended variant scorers); works for single-nucleotide variants, indels and multi-nucleotide variants. The result states source: live.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Example: "Compare the predicted effect of chr19:44908684 T>C in brain, liver and heart"
Inputs: alt (required), ref (required), position (required), chromosome (required), +1 more.
Predicted regulatory effect of a genetic variant, per modality: the strongest tracks of each scorer (expression, transcription start, chromatin accessibility, histone marks, transcription factor binding, splicing), each with its score, calibrated quantile, gene, tissue or cell type, and assay. From the Atlas the AlphaGenome Variant Impact (AVI) score is included.
Source: a single-nucleotide variant is answered from the precomputed AlphaGenome Atlas; an indel or multi-nucleotide variant runs live inference (score_variant). Both return the same scorers in the same shape. Chosen automatically, overridable with source, and always stated in the result.
The response is a summary, never a full score matrix: ranked rows only, capped at top_n (default 25, max 100) and at 40,000 characters.
Results are AlphaGenome model predictions for research prioritization, not clinical classifications: scores and calibrated quantiles are reported as returned, and no pathogenic/benign call is made.
Example: "Analyze chr19:44908684 T>C with AlphaGenome"
Inputs: alt (required), ref (required), position (required), chromosome (required), +4 more.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 24 tools
Several tools return essentially the same 'strongest effect per modality' summary — predict_variant_effect, assess_pathogenicity, annotate_regulatory_context, generate_variant_report and explain_variant_impact overlap heavily, differing mainly in verbosity. The comparison family (compare_variants, compare_alleles, compare_variants_same_gene, compare_protective_risk, batch_tissue_comparison) and the batch family (batch_score_variants, batch_modality_screen, batch_pathogenicity_filter, atlas_lookup_variants) also blur into each other. Legacy names that the descriptions explicitly disclaim (assess_pathogenicity, compare_protective_risk, batch_pathogenicity_filter) actively mislead selection.
All names are snake_case and almost all follow a verb_noun shape (predict_*, batch_*, compare_*, atlas_*, analyze_*, annotate_*, generate_*, explain_*). The atlas_* resource prefix and the varied verb set (predict/score/assess/analyze/compare/lookup/scan) are readable conventions rather than chaos. Minor deviation: some tools lead with an action while others lead with a scope prefix.
24 tools is on the heavy side for a variant-effect predictor, and a meaningful fraction are near-duplicates of a general scoring tool. Many could be folded into predict_variant_effect with parameters (modality, comparison mode, batch) without loss. The Atlas-vs-live distinction does justify some separate entries, but not this many.
The surface covers the full variant-scoring lifecycle: single variant, batch, region scan, Atlas lookup/list, per-modality breakdowns, tissue comparison, allele comparison and plain-language/narrative output. Gaps are minor — no non-variant sequence/annotation retrieval and no export/format options — but an agent can complete realistic prioritization workflows without dead ends.
Annotate and classify human genetic variants with GeneBe (ACMG, gnomAD, ClinVar). Research use only.
Pharmacogenomics for AI agents: cited drug–gene, gene and rsID lookups plus a medication screen.
MyVariant.info MCP. Aggregated human genetic-variant annotation: dbSNP, ClinVar clinical…
Find pharmacogenomics guidelines, translate diplotypes, and retrieve prescribing recommendations.