evo2-mcp-server
Provides tools for DNA sequence forward inference, likelihood scoring, and variant effect prediction using the NVIDIA-hosted Evo2-7B genomic foundation model API.
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., "@evo2-mcp-serverPredict the impact of a G to A change at position 4 in ACGTGCTA"
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.
Evo2-7B Bioinformatics MCP Server
An MCP (Model Context Protocol) Tools server that wraps the NVIDIA-hosted Evo2-7B Forward API, letting agents like Claude Code, Cursor, and Codex drive Evo2 with natural language:
Agent
↓
MCP Tool
↓
Evo2 MCP Server(本项目)
↓
NVIDIA Evo2-7B Forward API
↓
forward outputs → likelihood / variant scores
↓
AgentPOST https://health.api.nvidia.com/v1/biology/arc/evo2-7b/forward
Authorization: Bearer $NVIDIA_API_KEY1. Project Introduction
Provides 5 MCP Tools:
Tool | Purpose |
| Runs Evo2-7B forward inference on a DNA sequence, returns output statistics for the specified layer (or saves the raw tensor) |
| Computes the Evo2 model's model-based likelihood for a DNA sequence (total / mean / per-position) |
| Compares the impact of a single nucleotide variant on Evo2 sequence likelihood (Δ log-likelihood) |
| Batch-compares multiple nucleotide variants (reuses one WT forward, concurrency-limited, auto-deduplicated) |
| Scores each record in a FASTA (local paths restricted by the |
This project is a Bioinformatics MCP Tool Server, not a simple HTTP API wrapper:
Auto-validates / normalizes DNA sequences (uppercase, whitespace removal, explicit errors for illegal characters)
Computes likelihood based on official semantics (byte-level tokenizer + causal shift, see §17)
Layered output design (summary / raw / save) to prevent MCP context explosion
Complete error classification (400/401/403/404/408/413/422/429/5xx/timeout) + retry/backoff
API Key is only read from environment variables, never hardcoded, never logged
Bundled batch scripts:
scripts/score_fasta.py(batch FASTA scoring + embedding extraction, see §18) andscripts/analyze_run.py(clustering/classification/regression downstream analysis, see §19)
Related MCP server: Evo2 MCP Server
2. Evo2 API Introduction
Evo2 (Arc Institute / NVIDIA) is a DNA foundation model (StripedHyena2 architecture), with the 7B version having 32 layers, Apache-2.0 licensed, and a training context of up to 1M bp. NVIDIA provides a hosted NIM service:
Forward endpoint:
POST https://health.api.nvidia.com/v1/biology/arc/evo2-7b/forwardRequest body (official OpenAPI
ForwardInputs):{ "sequence": "ACGTACGT...", "output_layers": ["output_layer"] }output_layerssupports 1–100 layer names (e.g.output_layer,decoder.layers.24.mlp.linear_fc2,decoder.layers.3.self_attention,embedding,decoder.final_norm).Response body (official OpenAPI
ForwardOutputs):{"data": "<base64-encoded NPZ>", "elapsed_ms": <int>}; oversized responses may be returned withContent-Type: application/zip(raw NPZ bytes).output_layer= final logits, shape[seq_len, batch_size, 512](512 is the padded vocabulary size of the byte-level tokenizer).
⚠️ Deprecation notice (verified 2026-08-24): the
arc/evo2-7bendpoint hosted on build.nvidia.com is marked Deprecated (the page shows "This NIM Endpoint has been deprecated"). The official NIM documentation (docs.nvidia.com/nim/bionemo/evo2/latest/) describes an API identical to the hosted endpoint; if the hosted endpoint is unavailable, you can switch to a self-hosted NIM container and pointEVO2_MCP_BASE_URLtohttp://localhost:8000/biology/arc/evo2.
Verified Official Facts (implementation basis, 2026-08-24)
Item | Conclusion | Source |
Response format | JSON | NVIDIA NIM endpoints docs + hosted OpenAPI schema ( |
|
| Same as above ("Final output/logits") |
Vocabulary size | 512 (padded); byte-level tokenizer, 1 token per bp | NVIDIA docs + Arc/vortex |
A/C/G/T → logits index | A=65, C=67, T=84, G=71 (ASCII byte values) | NVIDIA docs verbatim + |
BOS/EOS/offset | No BOS by default (Arc | Arc |
Likelihood computation |
| Arc |
Special tokens | Only the 4 tokens A/C/G/T are meaningful in the output (NIM docs verbatim) | NVIDIA docs |
Differences Between Live Testing and Documentation (2026-08-24 live verification, task requires recording the actual interface)
Probing the hosted health.api.nvidia.com endpoint with a real key revealed that the layer names in the documentation do not apply to the hosted endpoint:
Requested layer name | Actual hosted API behavior |
| ❌ |
| ❌ 422 |
| ✅ Final logits: NPZ key |
| ✅ |
| ✅ |
| ✅ |
Mitigation (implemented and live-verified):
Added
EVO2_MCP_LOGITS_LAYERconfig (defaultauto): scoring tools first try the documented nameoutput_layer; if a422 has no attributeerror is received (hosted endpoint), they automatically switch tounembedand cache the result, avoiding repeated probing afterward; self-hosted NIM 2.x containers succeed on the first try with zero extra requests.The NPZ parser supports both bare keys (
output_layer) and<name>.output(unembed.output) key formats, with a "last dimension = 512" heuristic fallback.422error messages now hint at the attribute names available on the hosted endpoint.
If the returned
seq_lendoes not match the input sequence length (e.g. the server added padding/BOS), this server refuses to compute likelihood and returns raw statistics with a clear explanation, never guessing the alignment.
3. How to Get an NVIDIA API Key
Open https://build.nvidia.com/, click Get API Key in the top-right corner (requires an NVIDIA account login).
Create a key (in the form
nvapi-xxxxxxxx...).Set it in an environment variable, do not write it into code / config / Git:
export NVIDIA_API_KEY="nvapi-xxxxxxxx"Or copy
.env.exampleto.envand fill it in (.envis ignored by.gitignore).
4. Installation
# 推荐:pip / uv
pip install -e ".[dev]"
# 或
uv sync --extra dev
# 推荐(本项目自带):pixi 项目本地环境
pixi install
pixi run testRequires Python >= 3.10 (3.11+ recommended). Core dependencies: mcp>=2.0, httpx>=0.27, numpy>=1.26, pydantic>=2.6, python-dotenv>=1.0. The analysis script (scripts/analyze_run.py) additionally requires dev dependencies: scikit-learn, pandas, matplotlib.
5. Environment Variables
Variable | Default | Description |
| None (required) | API Key, only read from here |
|
| Service address (modify when self-hosting NIM) |
|
| HTTP read timeout (seconds) |
|
| Maximum retries for 408/429/5xx |
|
| Concurrency limit for batch/FASTA |
| empty | Directories allowed for FASTA reads ( |
|
| Output directory for |
|
| Set to |
|
| Hard upper limit for sequence length |
|
| Upper limit on total tensor elements allowed inline for |
|
| Upper limit for per-position list returns (takes head and tail beyond this) |
|
| Logits layer name for scoring: |
6. CLI Startup
# 三种方式等价
python -m evo2_mcp
evo2-mcp
uv run evo2-mcp # 用 uv 管理的项目环境
# pixi 环境:
pixi run evo2-mcpThe server communicates with MCP clients via stdio; there will be no output after a normal startup (waiting for the MCP handshake).
7. MCP Configuration
Claude Code (.mcp.json)
{
"mcpServers": {
"evo2": {
"command": "uv",
"args": ["run", "evo2-mcp"],
"env": {
"NVIDIA_API_KEY": "${NVIDIA_API_KEY}"
}
}
}
}Note: whether
${NVIDIA_API_KEY}is expanded by the client depends on the client implementation. The most reliable approach is to fill in the real key directly:
{
"mcpServers": {
"evo2": {
"command": "uv",
"args": ["run", "evo2-mcp"],
"env": {
"NVIDIA_API_KEY": "YOUR_API_KEY"
}
}
}
}But never commit a .mcp.json containing a real key to Git (add the file to .gitignore, or inject it via environment variables / a secret management tool). You can also omit env and let the server process read NVIDIA_API_KEY from its own environment or .env:
{
"mcpServers": {
"evo2": {
"command": "uv",
"args": ["run", "evo2-mcp"]
}
}
}Cursor (~/.cursor/mcp.json or project .cursor/mcp.json)
{
"mcpServers": {
"evo2": {
"command": "uv",
"args": ["run", "evo2-mcp"],
"env": { "NVIDIA_API_KEY": "YOUR_API_KEY" }
}
}
}Codex (~/.codex/config.toml)
[mcp_servers.evo2]
command = "uv"
args = ["run", "evo2-mcp"]
env = { "NVIDIA_API_KEY" = "YOUR_API_KEY" }Self-hosted NIM
{
"mcpServers": {
"evo2": {
"command": "uv",
"args": ["run", "evo2-mcp"],
"env": {
"EVO2_MCP_BASE_URL": "http://localhost:8000/biology/arc/evo2"
}
}
}
}8. Tool List
evo2_forward(sequence, output_layers=["output_layer"], mode="summary", save_path=None)
Runs Evo2-7B forward inference on a DNA sequence. mode:
"summary"(default): returnsshape / dtype / min / max / mean / stdper layer, context-safe;"save": saves the raw tensor as.npz(output/evo2_forward_<timestamp>.npz), returns the path;"raw": inlines the full tensor (only when the total element count ≤EVO2_MCP_RAW_INLINE_MAX, default 4096, to prevent context explosion).
Layer name note: the hosted
health.api.nvidia.comendpoint accepts model attribute names (useunembedfor logits; also available areembedding_layer,norm,blocks.N.mlp); the documented namesoutput_layer/decoder.layers.N.*only apply to self-hosted NIM 2.x containers.evo2_score/evo2_variant_score/evo2_batch_score/evo2_score_fastaauto-detect, so no manual specification is needed; only when callingevo2_forwarddirectly do you need to choose the name based on the actual endpoint.
evo2_score(sequence, include_per_position=False)
Computes Evo2's likelihood for a sequence:
{
"sequence_length": 123,
"total_log_likelihood": -123.45,
"mean_log_likelihood": -1.2345,
"scored_positions": 122,
"per_position_log_likelihood": null,
"method_notes": "...",
"disclaimer": "..."
}Semantics (consistent with the official Arc implementation): logits[i] predicts the base at position i+1; after log-softmax over the full 512 vocab, take the target base's byte index; position 0 does not participate in scoring, so scored_positions = length - 1, and mean is the average of these N-1 values. per_position_log_likelihood[k] corresponds to 0-based position k+1 of the sequence (i.e. 1-based position k+2). If the seq_len returned by the API cannot be aligned with the sequence, no fabricated results are produced; raw statistics are returned with a clear explanation:
Likelihood calculation is not supported until the API output format is verified.evo2_variant_score(sequence, position, ref, alt, coordinate="1-based", include_per_position=False)
{
"position": 100,
"ref": "A",
"alt": "G",
"wildtype_log_likelihood": -500.1,
"mutant_log_likelihood": -500.5,
"delta_log_likelihood": -0.4,
"interpretation": "The mutant sequence is less likely than the wildtype under Evo2-7B ... (NOT a clinical pathogenicity call)"
}Validation chain: position range → coordinate conversion → ref must match the base at that position in the sequence → ref≠alt → 1-based position 1 (0-based 0) cannot be scored (a causal LM cannot assign a probability to the first token) → explicit error.
evo2_batch_score(sequence, variants, coordinate="1-based")
{
"sequence_length": 300,
"wildtype_log_likelihood": -1200.0,
"variants": [
{ "position": 100, "ref": "A", "alt": "G", "delta_log_likelihood": -0.42 },
{ "position": 200, "ref": "C", "alt": "T", "delta_log_likelihood": 0.13 }
]
}WT forward is computed only once and reused for all variants;
Identical
(position, alt)mutants are only forwarded once (memoized);Concurrency is limited by
EVO2_MCP_MAX_CONCURRENCY(default 2, respecting NVIDIA rate limits);A single variant failure does not affect the whole batch (each entry returns its own
error).
evo2_score_fasta(fasta_path=None, fasta_text=None)
>sequence_1
ACGTACGT...
>sequence_2
TTGGCCAA...fasta_text: inline FASTA (available by default, with size/record-count limits);fasta_path: only readable if the file is insideEVO2_MCP_ALLOWED_DIRS, otherwise explicitly rejected;Returns
total_log_likelihood / mean_log_likelihoodper record; a single record's error does not affect the rest.
9. Usage Examples
{
"sequence": "acgtACGT acgt", // 小写 + 空白自动处理
"output_layers": ["output_layer"],
"mode": "summary"
}Returns:
{
"sequence_length": 12,
"requested_output_layers": ["output_layer"],
"returned_layers": ["output_layer"],
"layer_stats": [
{ "name": "output_layer", "shape": [12, 1, 512], "dtype": "float32",
"size": 6144, "min": -3.21, "max": 4.02, "mean": 0.01, "std": 0.98 }
],
"api": { "elapsed_ms": 87 }
}When an agent wants the full logits:
{ "sequence": "ACGT...", "mode": "save" }{
"saved": true,
"path": "/abs/path/output/evo2_forward_20260824_153000.npz",
"bytes_on_disk": 24576,
"layer_stats": [...]
}10. FASTA Example
{
"fasta_text": ">geneA\nACGTACGTACGT\n>geneB\nTTGGCCAATTGG"
}(or "fasta_path": "/data/genomes/genes.fa", requires configuring EVO2_MCP_ALLOWED_DIRS=/data/genomes)
For large-scale FASTA scoring (e.g. an entire directory of enhancers/promoters) plus embedding extraction, use scripts/score_fasta.py (see §18) — each run outputs an independent run folder (scores.csv + embeddings.npz).
11. Variant Scoring Example
{
"sequence": "ACGTACGTACGTACGTACGT",
"position": 10,
"ref": "A",
"alt": "G"
}12. Batch Scoring Example
{
"sequence": "ACGTACGTACGTACGTACGT",
"variants": [
{ "position": 10, "ref": "A", "alt": "G" },
{ "position": 12, "ref": "T", "alt": "C" },
{ "position": 14, "ref": "A", "alt": "T" }
]
}Typical agent workflow (corresponding to "analyze all SNPs on the sequence, find the top 20 with the largest Evo2 score changes"):
读取输入 → 解析 DNA / VCF → 生成 WT / mutant → evo2_batch_score
→ 按 |delta_log_likelihood| 排序 → 取前 20 → 保存 CSV → 解释结果13. Error Handling
HTTP | Meaning | This server's behavior |
400 | Bad Request (including invalid sequence, etc.) | Returns an error directly, with a response summary |
401 | Invalid API Key | Returns an error directly, prompting to check |
403 | No permission (managed endpoint deprecated, etc.) | Returns an error directly, prompting possible causes |
404 | Path does not exist | Returns an error directly, prompting to check |
408 | Server timeout | Returns an error after limited retries (backoff) |
413 | Payload too large | Returns an error directly, prompting to reduce sequence or layer count |
422 | Parameter validation failed | Returns an error directly, with details |
429 | Rate limit | Retry + exponential backoff (respects |
5xx | NVIDIA server error | Returns an error after limited retries |
timeout | Request timeout ( | Returns a clear error: |
All errors are returned through MCP as structured JSON: {"error": "Evo2APIError", "message": "..."}. In evo2_batch_score, a single failed item returns {"error": ..., "status": ...} without interrupting the whole batch.
14. Rate limit
NVIDIA's hosted NIM has rate limits. Design countermeasures:
EVO2_MCP_MAX_CONCURRENCY(default 2) limits concurrency;429 → exponential backoff (1s, 2s, 4s, 8s, 16s…, capped at 30s + jitter; if
Retry-Afteris present, follow it first but cap at 60s);Retry cap
EVO2_MCP_MAX_RETRIES(default 4), never retries indefinitely;Within a batch, WT is scored only once and identical mutants are deduplicated, reducing the number of requests.
15. Security notes
API Key: read only from the
NVIDIA_API_KEYenvironment variable (or.env); no hardcoded keys anywhere in the code; logs record only URLs, sequence lengths, and layer names, never sequence content or keys; error messages contain only a 500-character summary of the response.Sequence privacy: all logs/errors contain only a
preview(e.g.ACGT...GCTA (len=12345)).Path sandbox:
FASTA reading is limited to
EVO2_MCP_ALLOWED_DIRS; when not configured, all local paths are rejected;save_pathinmode="save"must be insideEVO2_MCP_OUTPUT_DIR;
.gitignorealready includes.env,*.env,output/,*.npz.N bases: rejected by default with a clear error (the Evo2 model has not been evaluated on ambiguous bases; the docs only guarantee that A/C/G/T are meaningful). If you really need to pass N through, start with
EVO2_MCP_ALLOW_AMBIGUOUS=1— this is an explicit choice, not silent dropping.Don't execute: this server performs no shell execution; Agents can only trigger restricted HTTP requests through FASTA/sequence input.
16. Biological interpretation limits
Evo2 score is a model-based sequence likelihood change, not experimental evidence, and certainly not a clinical pathogenicity diagnosis.
delta_log_likelihood < 0can only be interpreted as "the mutant sequence is less likely under the model", not as "pathogenic".Downstream validation (experiments, population frequency, ClinVar annotations, protein structure impact, etc.) is required before discussing pathogenicity.
Every Tool's description carries the following disclaimer (visible to MCP clients):
This is a DNA foundation model inference tool. It does not provide clinical
diagnosis. Model scores should not be interpreted as pathogenicity labels
without additional validation.17. Implementation basis and validation sources (2026-08-24)
NVIDIA NIM for Evo 2 — Endpoints: https://docs.nvidia.com/nim/bionemo/evo2/latest/endpoints.html
NVIDIA NIM for Evo 2 — Quickstart: https://docs.nvidia.com/nim/bionemo/evo2/latest/quickstart-guide.html
NVIDIA hosted API reference (arc/evo2-7b-forward OpenAPI schema): https://docs.api.nvidia.com/nim/reference/arc-evo2-7b-infer
Hosted endpoint tested live (2026-08-24, real key):
output_layerreturns 422StripedHyena has no attribute 'output_layer';unembedreturns logits (NPZ keyunembed.output, shape(1, seq, 512), float64) — therefore the scoring tool defaults toEVO2_MCP_LOGITS_LAYER=autofor automatic detectionBatch tested live (2026-08-25, real key, 3800+ K562 enhancer/promoter sequences):
Sequences > ~100 kb return 422 from the hosted endpoint (PyTorch
canUse32BitIndexMathlimit) — use--skip-longer-than 100000for batch runs;The race condition in automatic layer-name detection under concurrency has been fixed (
forward_logitsuses a local variable to record attempted names) and a regression test was added;Embedding extraction:
norm/embedding_layer/blocks.Nall work, shape(1, seq, 4096)float64 (4096 dimensions after mean-pooling).
Arc Institute Evo2 repository (
scoring.py,models.py): https://github.com/ArcInstitute/evo2vortex
CharLevelTokenizer(Evo2's official tokenizer implementation): PyPIvtx1.1.0 sourcevortex/model/tokenizer.pyEvo2 model card: https://huggingface.co/ArcInstitute/evo2_7b
If NVIDIA adjusts the API, defer to the latest official docs; EVO2_MCP_BASE_URL can be switched at any time.
18. Batch scoring and embedding extraction (scripts/score_fasta.py)
MCP Tools are suited for interactive Agent calls; large-batch FASTA scoring uses the companion script scripts/score_fasta.py (validated against the real API with 3800+ K562 enhancer/promoter sequences).
Each run automatically creates a separate timestamped folder:
output/run_20260825_104403/
├── scores.csv # 每序列一行:id, header, length, total/mean LL, ...
│ # + embedding_key(与 embeddings.npz 的 record_ids 对齐)
└── embeddings.npz # embeddings: (n, 4096) float32 mean-pooled 矩阵
# record_ids: 与矩阵行一一对应的键(来源__序列id)# 小样本(指定 id)
.pixi/envs/dev/bin/python scripts/score_fasta.py \
--fasta /path/cis/enhancers.fa /path/cis/promoters.fa \
--ids K562_TE_629,K562_MPT_6842 --allow-ambiguous
# 全量(跳过 >100kb —— 托管端对该长度返回 422;保留原始 embedding)
.pixi/envs/dev/bin/python scripts/score_fasta.py \
--fasta /path/cis/enhancers.fa /path/cis/promoters.fa \
/path/trans/enhancers.fa /path/trans/promoters.fa \
--skip-longer-than 100000 --allow-ambiguous \
--embedding-layer norm --keep-raw-embeddingsKey parameters:
Parameter | Description |
| Which layer's embedding to extract (default |
| Additionally saves each sequence's raw per-position embedding |
| Skips sequences longer than this (hosted API limit, see §17) |
| Allows N bases to pass through (5 sequences containing N run normally with a caveat warning) |
| Concurrency (default 2, respects rate limits) |
| Override the default run folder layout |
Efficiency design: each sequence sends only one request (output_layers=["unembed","norm"], logits and embedding fetched together); the logits layer name is probed only once per run; concurrency is limited by a semaphore.
19. Embedding association and downstream analysis (scripts/analyze_run.py)
embeddings.npz contains mean-pooled sequence representations (one 4096-dimensional vector per sequence), suitable for direct clustering, classification, and regression. Loading and association:
import csv, numpy as np
run = "output/run_20260825_104403"
rows = list(csv.DictReader(open(f"{run}/scores.csv")))
d = np.load(f"{run}/embeddings.npz", allow_pickle=True)
X = d["embeddings"] # (n, 4096) float32
ids = [str(x) for x in d["record_ids"]] # 与 X 行一一对应
key_to_row = {r["embedding_key"]: r for r in rows if r.get("embedding_key")}
scores = [key_to_row[k] for k in ids] # scores[i] ↔ X[i]Run the full analysis in one command (KMeans clustering, enhancer-vs-promoter classification, embedding→likelihood regression, PCA plot):
.pixi/envs/dev/bin/python scripts/analyze_run.py output/run_20260825_104403 --k 3Outputs analysis_<run>.npz (merged X + keys) and analysis_<run>.png. Analysis notes:
Unit-normalize 4096-dimensional vectors before similarity/clustering (the script already does this);
Classification/regression are automatically skipped for small samples (protection threshold ≥6 sequences); these analyses are only statistically meaningful after the full 3806 sequences have been run;
Key
cis_enhancers__xxx→ category enhancers, region cis;trans_*likewise (modifyparse_sourceto change label dimensions for cis-vs-trans classification).
Development and testing
pixi install # 或 pip install -e ".[dev]"
pixi run test # 运行 pytest(全部 mock,不调用真实 API)Offline tests 91 passed / 4 skipped (skips are live-gated). Coverage: sequence validation, case/whitespace normalization, invalid characters, missing API key, forward request construction, 401/408/429/5xx/timeout, automatic layer-name detection (including the concurrency race regression), variant validation, variant/batch scoring mathematical correctness (independently recomputed against Arc semantics), NPZ decoding (JSON base64 / zip / legacy JSON tensor / <layer>.output key), FASTA sandbox, MCP session integration, script pure functions (pooling/key names), etc.
Real API smoke tests (require a real key, skipped by default). The key is read automatically from .env (Settings.from_env() already loads it):
EVO2_MCP_RUN_LIVE=1 .pixi/envs/dev/bin/python -m pytest tests/test_live_api.py -v -sLive tests make real requests to the NVIDIA endpoint, verifying: automatic logits layer detection (unembed), real NPZ parsing ((1, seq, 512) float64), evo2_score matching manual recomputation from raw logits, and variant scores.
Project structure
.
├── pyproject.toml
├── README.md
├── .env.example
├── .gitignore
├── src/evo2_mcp/
│ ├── __main__.py # python -m evo2_mcp 入口
│ ├── config.py # 环境变量配置
│ ├── sequence.py # DNA 校验/归一化
│ ├── api_client.py # HTTP 客户端(retry/backoff/错误分类/响应解码 + layer 自动探测)
│ ├── forward_output.py# NPZ 解码 + likelihood 计算 + embedding 提取
│ ├── fasta.py # FASTA 解析 + 读取沙箱
│ ├── tools.py # 5 个 Tool 的实现
│ └── server.py # MCP server(stdio)
├── scripts/
│ ├── score_fasta.py # 批量 FASTA 评分 + embedding 提取(每次运行独立 run 文件夹)
│ └── analyze_run.py # 下游分析:加载/关联 → 聚类/分类/回归 + PCA 图
├── tests/ # pytest(全 mock,91 用例)+ 可选 live test
└── output/ # mode="save" 的 .npz 输出 + run_*/ 运行结果(git 忽略)Available Tools
5 toolsevo2_batch_scoreA
Score many single-nucleotide variants against one wildtype sequence. The WT forward pass is computed exactly once and reused; identical (position, alt) mutants are forwarded once; mutant requests run with bounded concurrency (EVO2_MCP_MAX_CONCURRENCY, default 2) to respect NVIDIA rate limits, and per-variant API errors are reported per-variant. Use for saturation-mutagenesis-style analyses. This is a DNA foundation model inference tool. It does not provide clinical diagnosis. Model scores should not be interpreted as pathogenicity labels without additional validation.
| Name | Required | Description | Default |
|---|---|---|---|
| sequence | Yes | Wildtype DNA sequence (>= 2 bp). | |
| variants | Yes | List of {position, ref, alt} dicts (1-based positions). | |
| coordinate | No | 1-based |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosure, and it excels. It reveals the caching behavior (WT pass computed once, identical mutants forwarded once), concurrency limits (EVO2_MCP_MAX_CONCURRENCY, default 2) to respect NVIDIA rate limits, and per-variant error reporting. It also adds crucial disclaimers (not clinical diagnosis, not pathogenicity labels). This is exemplary transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but every sentence earns its place. It leads with the core purpose, then efficiently packs performance details, error handling, and disclaimers. It is slightly longer than minimal but avoids fluff. The structure is logical: purpose → efficiency → safety/limitations. This is good, though a bit dense; a 4 feels right.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a batch scoring tool with no output schema, the description covers the execution semantics, concurrency, error reporting, and clinical disclaimer. However, it omits any description of the return format or how results are structured (even per-variant errors are mentioned but not the shape). Given the complexity and no annotations, the absence of output details leaves a small but notable gap, so it stops short of a 5.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 67% (sequence and variants have descriptions; coordinate has an enum with a default). The description does not add parameter-level meaning beyond what the schema already provides—it merely restates the variants structure and coordinate default implicitly. It does clarify the 'many' scope, but that is more behavioral than parameter-specific. Baseline 3 is appropriate since the schema covers most parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a strong, specific verb-resource pair: 'Score many single-nucleotide variants against one wildtype sequence.' It clearly states the batch scope and distinguishes itself from single-variant tools by emphasizing 'many' and 'batch.' It also specifies the analysis type (saturation-mutagenesis), which orients the agent on the intended use case.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The tool provides a clear when-to-use directive: 'Use for saturation-mutagenesis-style analyses.' It also implies batching by explaining the reuse of the WT forward pass and bounded concurrency. However, it does not explicitly name alternative sibling tools for single-variant scoring, so the agent must infer those from the 'many' qualifier. This is solid but not fully explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
evo2_forwardA
Run a forward pass of Evo2-7B on a DNA sequence (forward inference) and return summary statistics — or raw tensors — for the requested model layers (final logits, attention, MLP or embedding outputs). Use this when you need layer outputs for analysis, not just a scalar score. Modes: 'summary' (shape/dtype/min/max/mean/std per layer — default, context-safe), 'save' (write the .npz under the server's output dir and return the path), 'raw' (inline small tensors only; large tensors must be saved to a file instead). This is a DNA foundation model inference tool. It does not provide clinical diagnosis. Model scores should not be interpreted as pathogenicity labels without additional validation.
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | summary: per-layer shape/dtype/min/max/mean/std only. raw: inline the tensors as nested lists (small only, capped). save: always write an .npz file in the output dir and return its path. | summary |
| sequence | Yes | DNA sequence over {A,C,G,T}. Lowercase and whitespace are normalised. IUPAC ambiguity codes (N, R, Y, ...) are rejected unless the server was started with EVO2_MCP_ALLOW_AMBIGUOUS=1 (N only). | |
| save_path | No | Optional filename for the saved NPZ (implies mode='save'). Must resolve inside the server's output directory (EVO2_MCP_OUTPUT_DIR, default ./output). If omitted, a timestamped file is used. | |
| output_layers | No | Evo2 layer names. The final logits layer is 'output_layer' on self-hosted NIM 2.x containers, but the hosted health.api.nvidia.com endpoint uses model attribute names — use 'unembed' for final logits (also 'embedding_layer', 'norm', 'blocks.N.mlp'). Scoring tools auto-detect this. See https://docs.nvidia.com/nim/bionemo/evo2/latest/endpoints.html |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full responsibility. It discloses mode behavior (summary is context-safe, raw only for small tensors, save writes to server output dir), ambiguity-code handling with an environment flag, endpoint-dependent layer naming, and the clinical limitation. This is exceptionally transparent for a complex inference tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with purpose, then organizes modes and constraints in a logical flow. Every sentence provides distinct information—no filler. Dense but efficient, appropriate for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with four parameters, no output schema, and no annotations, this description is remarkably complete. It covers return types, mode constraints, output directory rules, ambiguity handling, endpoint differences, and disclaimers—everything an agent needs to invoke it correctly without external documentation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions already cover all parameters (100% coverage), but the description adds significant value: it explains the endpoint-specific layer names (output_layer vs unembed), the save_mode implication of save_path, and the ambiguity environment flag. This goes beyond the schema to make parameter usage clearer.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Run a forward pass of Evo2-7B') and explicitly contrasts with scoring tools: 'Use this when you need layer outputs for analysis, not just a scalar score.' This clearly distinguishes from sibling scoring tools and conveys the tool's core purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells when to use this tool versus alternatives ('not just a scalar score'), and details the three modes with their intended contexts. It also adds a clinical disclaimer ('does not provide clinical diagnosis'), guiding appropriate usage boundaries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
evo2_scoreA
Compute the model-based log-likelihood of a DNA sequence under Evo2-7B (nucleotide-level log-likelihood via the byte-level tokenizer). Returns total_log_likelihood, mean_log_likelihood, scored_positions and optionally per_position_log_likelihood (position 0 is unscored by the causal shift; value k corresponds to 0-based position k+1). Use for sequence-level probability estimates. This is a DNA foundation model inference tool. It does not provide clinical diagnosis. Model scores should not be interpreted as pathogenicity labels without additional validation.
| Name | Required | Description | Default |
|---|---|---|---|
| sequence | Yes | DNA sequence over {A,C,G,T} (>= 2 bp). | |
| include_per_position | No | Return the per-position log-likelihood list (default False to keep the response small; long lists are truncated to head+tail). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full behavioral burden. It discloses output structure, the causal shift causing position 0 to be unscored, optional per-position output, and explicitly warns against clinical diagnosis and pathogenicity interpretation. This is thorough and transparent for a model-scoring tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a few sentences but each adds necessary context: purpose, output details, usage, and disclaimers. It is not overly verbose and front-loads the core function. Slightly dense with parentheticals, but still efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema, the description fully explains the returned fields (total_log_likelihood, mean_log_likelihood, scored_positions, optional per_position_log_likelihood) and the positional convention. It also addresses interpretation caveats. For a single-sequence inference tool, nothing critical is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so both parameters are well-documented in the schema. The description adds little beyond the schema; it does explain the per-position output semantics within the overall description, but that is not parameter-specific. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool computes model-based log-likelihood of a DNA sequence under Evo2-7B, with specific output fields. It does not explicitly differentiate from siblings like evo2_batch_score or evo2_variant_score, but the single-sequence focus is implied by the parameter list and usage text.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides a clear context: 'Use for sequence-level probability estimates' and notes this is a DNA foundation model inference tool. It does not explicitly state when not to use it or mention alternatives, but the use case is specified clearly enough without being misleading.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
evo2_score_fastaA
Score every record in a FASTA source under Evo2-7B. Provide EITHER fasta_text (inline FASTA) OR fasta_path (local file — only allowed when its directory is listed in EVO2_MCP_ALLOWED_DIRS; the server refuses arbitrary paths). Returns per-record total/mean log-likelihood; per-record errors are reported inline. This is a DNA foundation model inference tool. It does not provide clinical diagnosis. Model scores should not be interpreted as pathogenicity labels without additional validation.
| Name | Required | Description | Default |
|---|---|---|---|
| fasta_path | No | Local FASTA path (sandboxed by EVO2_MCP_ALLOWED_DIRS). | |
| fasta_text | No | Inline FASTA text, e.g. '>seq1\nACGT...'. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full disclosure burden. It states the output type (per-record total/mean log-likelihood), error reporting behavior, and importantly warns that scores are not clinical diagnostics. It does not explicitly state read-only behavior, but for an inference tool this is implied and not a significant gap given the safety disclaimers.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact yet covers all essential aspects: purpose, input options, constraints, output, and limitations. The main action is front-loaded, and every sentence serves a purpose without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having no output schema, the description explains the return values clearly. It covers input constraints and error reporting, but does not specify the exact response format (e.g., whether it's a JSON object or text). For a tool with only two parameters, this is a minor gap, so a 4 is appropriate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptive parameter comments, so the baseline is 3. The description adds value by clarifying the meaning of the output (per-record scores) which is not in the schema, and reinforces the sandboxing constraint for fasta_path, going beyond the schema's own description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Score every record'), the specific resource (FASTA source), and the model (Evo2-7B). It also distinguishes itself from siblings by focusing on FASTA input, making it easily separable from evo2_score or evo2_variant_score without needing to infer.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly explains when to use the tool: 'Provide EITHER fasta_text OR fasta_path', with the path restriction clearly stated. It also provides cautionary guidance on interpreting results, which helps agents avoid misuse. The description mentions no alternatives but the either/or and sandboxing rules effectively guide usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
evo2_variant_scoreA
Compare a single-nucleotide variant: the Evo2-7B log-likelihood of the wildtype sequence vs the mutant sequence. Returns delta_log_likelihood (mutant − wildtype); a negative value means the mutant sequence is LESS likely under the model. Positions are 1-based by default (VCF-style). Variants at position 1 are rejected because a causal LM cannot score the first base. This is a DNA foundation model inference tool. It does not provide clinical diagnosis. Model scores should not be interpreted as pathogenicity labels without additional validation.
| Name | Required | Description | Default |
|---|---|---|---|
| alt | Yes | Alternate allele (single A/C/G/T). | |
| ref | Yes | Reference allele (single A/C/G/T). | |
| position | Yes | Variant position, 1-based by default. | |
| sequence | Yes | Wildtype DNA sequence context (>= 2 bp). | |
| coordinate | No | Coordinate system of `position`. | 1-based |
| include_per_position | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses behavioral traits: it explains the output meaning (negative delta indicates lower likelihood), the reasoning behind rejecting position 1 (causal LM limitation), coordinate system default, and important limitations (not clinical, not pathogenicity). This goes well beyond a basic verb+object statement and gives the agent a clear model of 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is four sentences with no redundancy. It front-loads the core purpose and output interpretation, then adds constraints and domain caveats. Every sentence carries meaningful information, and the structure makes it easy for an agent to quickly grasp the tool's role.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having no output schema or annotations, the description covers the essential aspects: what it computes, how to interpret the result, coordinate system, positional restriction, and domain limitations. It does not explicitly describe the effect of include_per_position (though schema notes default false), but that is a minor gap. Overall, an agent has sufficient context to call the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is high (83%), so the baseline is 3. The description adds semantic value by explaining the output delta and the coordinate system, but it does not elaborate on parameters that the schema already documents. It reinforces the 'sequence' as wildtype context, which is consistent with schema descriptions, but adds no new parameter-level nuance beyond the position-1 rejection rule.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Compare a single-nucleotide variant') and defines the exact output ('delta_log_likelihood (mutant − wildtype)'). It clearly distinguishes the tool from siblings by focusing on variant comparison rather than generic scoring or batch operations. The inclusion of the model name (Evo2-7B) and the caveat about clinical diagnosis further clarify its purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool (for single-nucleotide variant scoring) but does not explicitly compare with siblings like evo2_score or evo2_batch_score. It does provide usage constraints (1-based positions, rejection of position 1, not for clinical diagnosis) that help an agent decide applicability, yet it lacks an explicit 'use when' versus 'use instead' statement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
5 tool updates
v0.1.0- First observed
evo2_batch_score - First observed
evo2_forward - First observed
evo2_score - First observed
evo2_score_fasta - First observed
evo2_variant_score
TDQS
Scored across 5 tools
Each tool has a clearly distinct purpose: forward pass for layer tensors, sequence log-likelihood scoring, single variant effect, batch variant scoring, and FASTA-based scoring. The descriptions clearly delineate usage scenarios, reducing misselection risk.
All tools follow the evo2_ verb-noun pattern (forward, score, variant_score, batch_score, score_fasta). While the second part varies, the consistent prefix and action-oriented naming make the set predictable and easy to navigate.
Five tools is well-scoped for a focused DNA model inference server. Each tool adds a distinct capability without redundancy, covering single sequence, variant, batch, and file-based scoring.
The surface covers the core workflows for an Evo2 model: sequence scoring, variant effect analysis (single and batch), FASTA batch processing, and forward pass tensor extraction. No obvious dead ends or missing critical operations for the stated purpose.
Maintenance
Related MCP Connectors
Protein analysis: ESM-2/ESMC embeddings, mutation scoring, landscape scans, ESMFold structure.
Hosted DNA language models: promoter, splice, enhancer, chromatin, expression, annotation
Bioinformatics MCP for genomic variant interpretation, gene-disease evidence and literature.
AI-powered bioprotocol optimization — generate, search, and manage lab protocols via MCP
Related MCP Servers
- AlicenseBqualityDmaintenanceEnables AI-powered genomic variant analysis including variant impact prediction, regulatory element discovery, and batch variant scoring. Currently operates in mock mode as a proof-of-concept awaiting the public release of Google DeepMind's AlphaGenome API.209 npm2MIT
- AlicenseAqualityCmaintenanceEnables genomic sequence analysis through the Evo 2 model, supporting DNA sequence scoring, embedding, generation, and variant effect prediction with multiple model checkpoints (7B, 40B, 1B parameters).62LGPL 3.0

bio-mcp-evo2official
AlicenseNot gradedqualityDmaintenanceAn MCP server that enables AI assistants to generate, score, and analyze DNA sequences using the evo2 genomic foundation model. It supports multiple execution modes including local GPU, SLURM clusters, and the Nvidia NIM cloud API for tasks like variant effect prediction and sequence embedding.1MIT- FlicenseNot gradedqualityDmaintenanceEnables protein sequence analysis and structure prediction by extracting ESM-2 embeddings and batch processing FASTA files via Docker. It provides tools for large-scale embedding extraction, job monitoring, and model management within an MCP-compatible environment.-