evo2-mcp-server
Evo2-7B Bioinformatics MCP Server
Ein Server, der die von NVIDIA gehostete Evo2-7B Forward API als MCP (Model Context Protocol) Tools kapselt, sodass Agents wie Claude Code, Cursor, Codex Evo2 über natürliche Sprache steuern können:
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. Projektübersicht
Stellt 5 MCP-Tools bereit:
Tool | Funktion |
| Führt Evo2-7B-Forward-Inferenz auf einer DNA-Sequenz aus und gibt Statistiken der Ausgabe der angegebenen Layer zurück (oder speichert den rohen Tensor) |
| Berechnet die modellbasierte Likelihood des Evo2-Modells für eine DNA-Sequenz (total / mean / per-position) |
| Vergleicht den Effekt einer einzelnen Nukleotidvariante auf die Evo2-Sequenz-Likelihood (Δ log-likelihood) |
| Vergleicht mehrere Nukleotidvarianten im Stapel (nutzt einen einzigen WT-Forward, begrenzte Parallelität, automatische Deduplizierung) |
| Bewertet jeden Datensatz in einer FASTA-Datei (lokale Pfade durch die |
Dieses Projekt ist ein Bioinformatics MCP Tool Server, kein einfacher HTTP-API-Wrapper:
Automatische Validierung/Normalisierung von DNA-Sequenzen (Großschreibung, Entfernen von Leerzeichen, klare Fehlermeldung bei ungültigen Zeichen)
Berechnung der Likelihood basierend auf der offiziellen Semantik (Byte-Level-Tokenizer + Causal Shift, siehe §17)
Mehrstufiges Ausgabedesign (summary / raw / save), um eine Explosion des MCP-Kontexts zu verhindern
Vollständige Fehlerklassifizierung (400/401/403/404/408/413/422/429/5xx/Timeout) + Retry/Backoff
API-Key wird nur aus Umgebungsvariablen gelesen, niemals hartkodiert, niemals in Logs
Begleitende Batch-Skripte:
scripts/score_fasta.py(Batch-FASTA-Scoring + Embedding-Extraktion, siehe §18) undscripts/analyze_run.py(Cluster-/Klassifikations-/Regressions-Nachanalyse, siehe §19)
Related MCP server: bio-mcp-evo2
2. Einführung in die Evo2-API
Evo2 (Arc Institute / NVIDIA) ist ein DNA-Basismodell (StripedHyena2-Architektur); die 7B-Version hat 32 Layer, ist Apache-2.0-lizenziert und hat einen Trainingskontext von bis zu 1M bp. NVIDIA bietet einen gehosteten NIM-Dienst an:
Forward-Endpunkt:
POST https://health.api.nvidia.com/v1/biology/arc/evo2-7b/forwardAnfragekörper (offizielles OpenAPI
ForwardInputs):{ "sequence": "ACGTACGT...", "output_layers": ["output_layer"] }output_layersunterstützt 1–100 Layernamen (z. B.output_layer,decoder.layers.24.mlp.linear_fc2,decoder.layers.3.self_attention,embedding,decoder.final_norm).Antwortkörper (offizielles OpenAPI
ForwardOutputs):{"data": "<base64 编码的 NPZ>", "elapsed_ms": <int>}; sehr große Antworten können mitContent-Type: application/zip(rohe NPZ-Bytes) zurückgegeben werden.output_layer= finale Logits, Shape[seq_len, batch_size, 512](512 ist die gepaddete Vocabulary-Größe des Byte-Level-Tokenizers).
⚠️ Deprecation-Hinweis (am 2026-08-24 verifiziert): Der auf build.nvidia.com gehostete
arc/evo2-7b-Endpunkt wurde als Deprecated markiert (Seite zeigt „This NIM Endpoint has been deprecated"). Die offizielle NIM-Dokumentation (docs.nvidia.com/nim/bionemo/evo2/latest/) beschreibt eine API, die mit dem gehosteten Endpunkt völlig übereinstimmt; falls der gehostete Endpunkt nicht verfügbar ist, kann stattdessen ein selbst gehosteter NIM-Container verwendet werden, wobeiEVO2_MCP_BASE_URLaufhttp://localhost:8000/biology/arc/evo2zeigt.
Verifizierte offizielle Fakten (Implementierungsbasis, 2026-08-24)
Aspekt | Ergebnis | Quelle |
Antwortformat | JSON | NVIDIA-NIM-Endpunktdokumentation + gehostetes OpenAPI-Schema ( |
|
| Ebenda („Final output/logits") |
Vocabulary-Größe | 512 (gepaddet); Byte-Level-Tokenizer, 1 bp = 1 Token | NVIDIA-Dokumentation + Arc/vortex |
A/C/G/T → logits index | A=65, C=67, T=84, G=71 (ASCII-Bytewerte) | Originaltext der NVIDIA-Dokumentation + |
BOS/EOS/offset | Standardmäßig kein BOS (Arc | Arc |
Likelihood-Berechnung |
| Arc |
Spezielle Tokens | Im Output sind nur die 4 Tokens A/C/G/T bedeutungsvoll (Originaltext der NIM-Dokumentation) | NVIDIA-Dokumentation |
Unterschiede zwischen Live-Test und Dokumentation (Live-Verifizierung am 2026-08-24; die Aufgabe verlangt die Erfassung der tatsächlichen API)
Beim Testen des gehosteten health.api.nvidia.com-Endpunkts mit einem echten Key wurde festgestellt, dass die in der Dokumentation genannten Layernamen auf dem gehosteten Endpunkt nicht gelten:
Angefragter Layername | Tatsächliches Verhalten der gehosteten API |
| ❌ |
| ❌ 422 |
| ✅ finale Logits: NPZ-Key |
| ✅ |
| ✅ |
| ✅ |
Gegenmaßnahmen (implementiert und live bestanden):
Neue Konfiguration
EVO2_MCP_LOGITS_LAYER(Standardauto): Die Scoring-Tools versuchen zuerst den Dokumentationsnamenoutput_layer; bei422 has no attribute(gehosteter Endpunkt) wechseln sie automatisch zuunembedund cachen die Wahl, sodass keine weitere Erkundung nötig ist. Bei selbst gehosteten NIM-2.x-Containern gelingt der Aufruf sofort, ohne zusätzliche Anfragen.Der NPZ-Parser unterstützt sowohl nackte Keys (
output_layer) als auch<name>.output(unembed.output) und greift als Fallback auf die Heuristik „letzte Dimension = 512" zurück.422-Fehlermeldungen weisen jetzt auf die auf dem gehosteten Endpunkt verfügbaren Attributnamen hin.
Wenn das zurückgegebene
seq_lennicht mit der Länge der Eingabesequenz übereinstimmt (z. B. weil der Server Padding/BOS hinzugefügt hat), verweigert dieser Server die Berechnung der Likelihood und gibt rohe Statistiken + eine klare Erklärung zurück; eine Ausrichtung wird nie erraten.
3. NVIDIA-API-Key erhalten
Öffnen Sie https://build.nvidia.com/, oben rechts Get API Key (Anmeldung mit NVIDIA-Konto erforderlich).
Erstellen Sie einen Key (in der Form
nvapi-xxxxxxxx...).Setzen Sie ihn als Umgebungsvariable, nicht in Code / Konfiguration / Git:
export NVIDIA_API_KEY="nvapi-xxxxxxxx"Oder kopieren Sie
.env.examplezu.envund füllen Sie es aus (.envwird von.gitignoreignoriert).
4. Installation
# 推荐:pip / uv
pip install -e ".[dev]"
# 或
uv sync --extra dev
# 推荐(本项目自带):pixi 项目本地环境
pixi install
pixi run testErfordert Python >= 3.10 (empfohlen 3.11+). Kernabhängigkeiten: mcp>=2.0, httpx>=0.27, numpy>=1.26, pydantic>=2.6, python-dotenv>=1.0. Das AnalysesSkript (scripts/analyze_run.py) benötigt zusätzlich Dev-Abhängigkeiten: scikit-learn, pandas, matplotlib.
5. Umgebungsvariablen
Variable | Standard | Beschreibung |
| Keiner (erforderlich) | API-Key, wird nur von hier gelesen |
|
| Dienstadresse (bei selbst gehostetem NIM ändern) |
|
| HTTP-Lese-Timeout (Sekunden) |
|
| Maximale Anzahl Wiederholungen bei 408/429/5xx |
|
| Maximale Parallelität für Batch/FASTA |
| leer | Verzeichnisse, aus denen FASTA-Dateien gelesen werden dürfen ( |
|
| Ausgabeverzeichnis für |
|
| Auf |
|
| Harte Obergrenze für Sequenzlänge |
|
| Maximale Gesamtzahl der Tensor-Elemente, die bei |
|
| Obergrenze für zurückgegebene Per-Position-Listen (bei Überschreitung werden Anfang und Ende genommen) |
|
| Layername für Logits beim Scoring: |
6. CLI-Start
# 三种方式等价
python -m evo2_mcp
evo2-mcp
uv run evo2-mcp # 用 uv 管理的项目环境
# pixi 环境:
pixi run evo2-mcpDer Server kommuniziert über stdio mit MCP-Clients; nach erfolgreichem Start gibt es keine Ausgabe (wartet auf den MCP-Handshake).
7. MCP-Konfiguration
Claude Code (.mcp.json)
{
"mcpServers": {
"evo2": {
"command": "uv",
"args": ["run", "evo2-mcp"],
"env": {
"NVIDIA_API_KEY": "${NVIDIA_API_KEY}"
}
}
}
}Hinweis: Ob
${NVIDIA_API_KEY}vom Client expandiert wird, hängt von der Client-Implementierung ab. Die sicherste Methode ist, den echten Key direkt einzutragen:
{
"mcpServers": {
"evo2": {
"command": "uv",
"args": ["run", "evo2-mcp"],
"env": {
"NVIDIA_API_KEY": "YOUR_API_KEY"
}
}
}
}Aber committen Sie niemals eine .mcp.json mit einem echten Key nach Git (fügen Sie die Datei zu .gitignore hinzu oder injizieren Sie den Key über Umgebungsvariablen/Secret-Management-Tools). Alternativ kann env weggelassen werden; der Server-Prozess liest NVIDIA_API_KEY selbst aus der Umgebung oder .env:
{
"mcpServers": {
"evo2": {
"command": "uv",
"args": ["run", "evo2-mcp"]
}
}
}Cursor (~/.cursor/mcp.json oder Projekt-.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" }Selbst gehostetes NIM
{
"mcpServers": {
"evo2": {
"command": "uv",
"args": ["run", "evo2-mcp"],
"env": {
"EVO2_MCP_BASE_URL": "http://localhost:8000/biology/arc/evo2"
}
}
}
}8. Tool-Liste
evo2_forward(sequence, output_layers=["output_layer"], mode="summary", save_path=None)
Führt Evo2-7B-Forward-Inferenz auf einer DNA-Sequenz aus. mode:
"summary"(Standard): gibt für jeden Layershape / dtype / min / max / mean / stdzurück, kontextsicher;"save": speichert den rohen Tensor als.npz(output/evo2_forward_<时间戳>.npz) und gibt den Pfad zurück;"raw": gibt den vollständigen Tensor inline zurück (nur wenn die Gesamtzahl der Elemente ≤EVO2_MCP_RAW_INLINE_MAX, Standard 4096, um eine Kontextexplosion zu verhindern).
Hinweis zu Layernamen: Der gehostete Endpunkt
health.api.nvidia.comakzeptiert Modellattributnamen (für Logitsunembed, außerdemembedding_layer,norm,blocks.N.mlp); die Dokumentationsnamenoutput_layer/decoder.layers.N.*gelten nur für selbst gehostete NIM-2.x-Container.evo2_score/evo2_variant_score/evo2_batch_score/evo2_score_fastaerkennen dies automatisch, keine manuelle Angabe nötig; nur beim direkten Aufruf vonevo2_forwardmuss der Name passend zum tatsächlichen Endpunkt gewählt werden.
evo2_score(sequence, include_per_position=False)
Berechnet die Likelihood von Evo2 für die Sequenz:
{
"sequence_length": 123,
"total_log_likelihood": -123.45,
"mean_log_likelihood": -1.2345,
"scored_positions": 122,
"per_position_log_likelihood": null,
"method_notes": "...",
"disclaimer": "..."
}Semantik (übereinstimmend mit der offiziellen Arc-Implementierung): logits[i] sagt die Base an Position i+1 voraus; nach Log-Softmax über den vollständigen 512-Vocab wird der Byte-Index der Zielbase genommen; Position 0 geht nicht in die Bewertung ein, daher gilt scored_positions = length - 1, und mean ist der Durchschnitt dieser N-1 Werte. per_position_log_likelihood[k] entspricht der 0-basierten Position k+1 (also der 1-basierten Position k+2). Wenn das von der API zurückgegebene seq_len nicht zur Sequenz ausgerichtet werden kann, werden keine Ergebnisse erfunden; es werden rohe Statistiken und eine klare Erklärung zurückgegeben:
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)"
}Validierungskette: Positionsbereich → Koordinatenumrechnung → ref muss mit der Base an dieser Position der Sequenz übereinstimmen → ref≠alt → 1-basierte Position 1 (0-basiert 0) kann nicht bewertet werden (ein kausales LM kann dem ersten Token keine Wahrscheinlichkeit zuweisen) → klare Fehlermeldung.
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 }
]
}Der WT-Forward wird nur einmal berechnet und für alle Varianten wiederverwendet;
Mutanten mit gleichem
(position, alt)werden nur einmal ge-forewarded (Memoization);Die Parallelität ist durch
EVO2_MCP_MAX_CONCURRENCYbegrenzt (Standard 2, respektiert das NVIDIA-Rate-Limit);Ein einzelner Variantenfehler beeinträchtigt nicht den gesamten Batch (pro Eintrag wird
errorzurückgegeben).
evo2_score_fasta(fasta_path=None, fasta_text=None)
>sequence_1
ACGTACGT...
>sequence_2
TTGGCCAA...fasta_text: Inline-FASTA (standardmäßig verfügbar, mit Größen-/Datensatz-Obergrenzen);fasta_path: Lesen nur erlaubt, wenn die Datei innerhalb vonEVO2_MCP_ALLOWED_DIRSliegt; andernfalls klare Ablehnung;Gibt pro Eintrag
total_log_likelihood / mean_log_likelihoodzurück; ein einzelner Fehler wirkt sich nicht auf die übrigen aus.
9. Anwendungsbeispiele
{
"sequence": "acgtACGT acgt", // 小写 + 空白自动处理
"output_layers": ["output_layer"],
"mode": "summary"
}Rückgabe:
{
"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 }
}Wenn der Agent die vollständigen Logits möchte:
{ "sequence": "ACGT...", "mode": "save" }{
"saved": true,
"path": "/abs/path/output/evo2_forward_20260824_153000.npz",
"bytes_on_disk": 24576,
"layer_stats": [...]
}10. FASTA-Beispiel
{
"fasta_text": ">geneA\nACGTACGTACGT\n>geneB\nTTGGCCAATTGG"
}(oder "fasta_path": "/data/genomes/genes.fa"; dafür muss EVO2_MCP_ALLOWED_DIRS=/data/genomes konfiguriert sein)
Für großes FASTA-Scoring (z. B. ganze Verzeichnisse mit Enhancern/Promotern) plus Embedding-Extraktion verwenden Sie scripts/score_fasta.py (siehe §18) – jeder Lauf erzeugt einen eigenen Run-Ordner (scores.csv + embeddings.npz).
11. Beispiel für Varianten-Scoring
{
"sequence": "ACGTACGTACGTACGTACGT",
"position": 10,
"ref": "A",
"alt": "G"
}12. Beispiel für Batch-Scoring
{
"sequence": "ACGTACGTACGTACGTACGT",
"variants": [
{ "position": 10, "ref": "A", "alt": "G" },
{ "position": 12, "ref": "T", "alt": "C" },
{ "position": 14, "ref": "A", "alt": "T" }
]
}Typischer Agent-Workflow (entspricht „Analysiere alle SNPs auf der Sequenz und finde die 20 mit der größten Änderung des Evo2-Scores"):
读取输入 → 解析 DNA / VCF → 生成 WT / mutant → evo2_batch_score
→ 按 |delta_log_likelihood| 排序 → 取前 20 → 保存 CSV → 解释结果13. Fehlerbehandlung
HTTP | Bedeutung | Verhalten dieses Servers |
400 | Bad Request (einschließlich ungültiger Sequenzen usw.) | Gibt sofort einen Fehler aus, mit Antwortzusammenfassung |
401 | API-Key ungültig | Gibt sofort einen Fehler aus und weist darauf hin, |
403 | Keine Berechtigung (verwalteter Endpunkt veraltet usw.) | Gibt sofort einen Fehler aus und nennt mögliche Ursachen |
404 | Pfad existiert nicht | Gibt sofort einen Fehler aus und weist darauf hin, |
408 | Server-Timeout | Fehler nach begrenzten Wiederholungen (backoff) |
413 | Payload zu groß | Gibt sofort einen Fehler aus und empfiehlt, die Sequenz oder die Anzahl der Layer zu reduzieren |
422 | Parametervalidierung fehlgeschlagen | Gibt sofort einen Fehler mit Details aus |
429 | Rate limit | Wiederholung + exponentieller Backoff (beachtet |
5xx | NVIDIA-Serverfehler | Fehler nach begrenzten Wiederholungen |
timeout | Anfrage-Timeout ( | Eindeutige Fehlermeldung: |
Alle Fehler werden über MCP als strukturiertes JSON zurückgegeben: {"error": "Evo2APIError", "message": "..."}. Ein einzelner Fehlschlag in evo2_batch_score liefert {"error": ..., "status": ...} zurück und unterbricht den gesamten Batch nicht.
14. Rate limit
Das von NVIDIA gehostete NIM hat ein Rate Limit. Design-Gegenmaßnahmen:
EVO2_MCP_MAX_CONCURRENCY(Standard 2) begrenzt die Parallelität;429 → exponentieller Backoff (1s, 2s, 4s, 8s, 16s…, Deckelung bei 30s + Jitter; falls
Retry-Aftervorhanden, wird dieses bevorzugt befolgt, aber mit Obergrenze 60s);Wiederholungsobergrenze
EVO2_MCP_MAX_RETRIES(Standard 4), keine unendlichen Wiederholungen;Innerhalb eines Batches wird der WT nur einmal berechnet, identische Mutanten werden dedupliziert, um die Anzahl der Anfragen zu reduzieren.
15. Sicherheitshinweise
API-Key: Wird nur aus der Umgebungsvariable
NVIDIA_API_KEY(oder.env) gelesen; es gibt keinen hartkodierten Key im Code; Logs erfassen nur URL, Sequenzlänge und Layer-Namen, keine Sequenzinhalte oder Keys; Fehlermeldungen enthalten nur eine Zusammenfassung der ersten 500 Zeichen der Antwort.Sequenz-Privatsphäre: Alle Logs/Fehler enthalten nur
preview(z. B.ACGT...GCTA (len=12345)).Pfad-Sandbox:
FASTA-Lesen ausschließlich innerhalb von
EVO2_MCP_ALLOWED_DIRS; wenn nicht konfiguriert, werden alle lokalen Pfade abgelehnt;Der
save_pathbeimode="save"muss innerhalb vonEVO2_MCP_OUTPUT_DIRliegen;
.gitignoreenthält bereits.env,*.env,output/,*.npz.N-Basen: Standardmäßig abgelehnt mit eindeutiger Fehlermeldung (das Evo2-Modell wurde nicht auf mehrdeutigen Basen evaluiert; die Dokumentation garantiert nur, dass A/C/G/T aussagekräftig sind). Falls N tatsächlich durchgereicht werden muss, mit
EVO2_MCP_ALLOW_AMBIGUOUS=1starten – das ist eine explizite Entscheidung, kein stilles Verwerfen.Don't execute: Dieser Server führt keinerlei Shell-Ausführungen aus; über FASTA-/Sequenzeingaben kann der Agent nur eingeschränkte HTTP-Anfragen auslösen.
16. Grenzen der biologischen Interpretation
Der Evo2-Score ist eine model-based sequence likelihood change, keine experimentelle Evidenz und schon gar keine klinische Pathogenitätsdiagnose.
delta_log_likelihood < 0darf nur als „die Mutantensequenz ist unter dem Modell unwahrscheinlicher" interpretiert werden, nicht als „pathogen".Erst mit Downstream-Validierung (Experimente, Populationsfrequenzen, ClinVar-Annotationen, Auswirkungen auf die Proteinstruktur usw.) kann über Pathogenität gesprochen werden.
Die Beschreibung jedes Tools enthält den folgenden Hinweis (für MCP-Clients sichtbar):
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. Implementierungsgrundlagen und Validierungsquellen (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
Referenz der von NVIDIA gehosteten API (arc/evo2-7b-forward OpenAPI-Schema): https://docs.api.nvidia.com/nim/reference/arc-evo2-7b-infer
Praxistest des verwalteten Endpunkts (2026-08-24, echter Key):
output_layerliefert 422StripedHyena has no attribute 'output_layer';unembedliefert die Logits (NPZ-Keyunembed.output, Shape(1, seq, 512), float64) – daher erkennt das Scoring-Tool den Layer standardmäßig automatisch überEVO2_MCP_LOGITS_LAYER=auto.Praxistest im Batch (2026-08-25, echter Key, 3800+ K562-Enhancer/Promotoren):
Bei Sequenzen > ~100 kb liefert der verwaltete Endpunkt 422 (PyTorch-
canUse32BitIndexMath-Limit) – für Batch-Läufe--skip-longer-than 100000verwenden;Der Race Condition bei der automatischen Erkennung des Layer-Namens unter Parallelität wurde behoben (
forward_logitsverwendet lokale Variablen, um die Versuchsnamen zu erfassen) und mit einem Regressionstest abgesichert;Embedding-Extraktion:
norm/embedding_layer/blocks.Nsind alle verfügbar, Shape(1, seq, 4096)float64 (nach Mean-Pooling 4096-dimensional).
Arc-Institute-Evo2-Repository (
scoring.py,models.py): https://github.com/ArcInstitute/evo2vortex
CharLevelTokenizer(offizielle Evo2-Tokenizer-Implementierung): PyPI-vtx-1.1.0-Quellcodevortex/model/tokenizer.pyEvo2-Modellkarte: https://huggingface.co/ArcInstitute/evo2_7b
Falls NVIDIA die API anpasst, gilt die offizielle aktuelle Dokumentation; EVO2_MCP_BASE_URL kann jederzeit umgestellt werden.
18. Batch-Scoring und Embedding-Extraktion (scripts/score_fasta.py)
MCP-Tools eignen sich für interaktive Agent-Aufrufe; für Batch-Scoring großer FASTA-Mengen dient das zugehörige Skript scripts/score_fasta.py (mit der echten API anhand von 3800+ K562-Enhancer/Promotoren validiert).
Jeder Lauf erstellt automatisch einen eigenen Ordner mit Zeitstempel:
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-embeddingsWichtige Parameter:
Parameter | Beschreibung |
| Von welchem Layer das Embedding extrahiert wird (Standard |
| Zusätzlich jedes rohe positionsweise Embedding |
| Sequenzen überspringen, die länger als dieser Wert sind (Limit der verwalteten API, siehe §17) |
| N-Basen-Durchreichung erlauben (5 N-haltige Sequenzen laufen normal mit Caveat-Warnung) |
| Parallelität (Standard 2, respektiert das Rate Limit) |
| Überschreibt das Standard-Layout des Run-Ordners |
Effizienzdesign: Pro Sequenz wird nur eine Anfrage gesendet (output_layers=["unembed","norm"], Logits und Embedding werden zusammen abgerufen); der Logits-Layer-Name wird pro Lauf nur einmal erkannt; die Parallelität wird über ein Semaphor begrenzt.
19. Embedding-Verknüpfung und Downstream-Analyse (scripts/analyze_run.py)
embeddings.npz ist die mean-gepoolte Sequenzrepräsentation (ein 4096-dimensionaler Vektor pro Sequenz) und eignet sich direkt für Clusterung, Klassifikation und Regression. Laden und Verknüpfen:
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]Gesamte Analyse mit einem Befehl ausführen (KMeans-Clusterung, Enhancer-vs-Promoter-Klassifikation, Embedding→Likelihood-Regression, PCA-Diagramm):
.pixi/envs/dev/bin/python scripts/analyze_run.py output/run_20260825_104403 --k 3Ausgabe analysis_<run>.npz (zusammengeführtes X + keys) und analysis_<run>.png. Analyse-Hinweise:
Vor Ähnlichkeits-/Clusterungsberechnungen die 4096-dimensionalen Vektoren zuerst auf Einheitslänge normalisieren (im Skript bereits erledigt);
Bei kleinen Stichproben werden Klassifikation/Regression automatisch übersprungen (Schutzschwelle ≥6 Einträge); erst nach dem vollständigen Lauf mit allen 3806 Einträgen sind diese Analysen statistisch aussagekräftig;
Schlüssel
cis_enhancers__xxx→ Kategorie enhancers, Region cis;trans_*analog (parse_sourcekann die Label-Dimension für eine cis-vs-trans-Klassifikation ändern).
Entwicklung und Tests
pixi install # 或 pip install -e ".[dev]"
pixi run test # 运行 pytest(全部 mock,不调用真实 API)Offline-Tests 91 passed / 4 skipped (skip = Live-Gating). Abgedeckt: Sequenzvalidierung, Normalisierung von Groß-/Kleinschreibung und Leerzeichen, ungültige Zeichen, fehlender API-Key, Konstruktion der Forward-Anfrage, 401/408/429/5xx/timeout, automatische Erkennung des Layer-Namens (inklusive Regressionstest für Race Conditions), Variantenvalidierung, mathematische Korrektheit des Varianten-/Batch-Scorings (unabhängig gegen die Arc-Semantik nachgerechnet), NPZ-Dekodierung (JSON base64 / zip / alte JSON-Tensoren / <layer>.output-Key), FASTA-Sandbox, MCP-Session-Integration, reine Skriptfunktionen (Pooling/Schlüsselnamen) usw.
Live-API-Smoke-Test (erfordert einen echten Key; standardmäßig übersprungen). Der Key wird automatisch aus .env gelesen (Settings.from_env() bereits geladen):
EVO2_MCP_RUN_LIVE=1 .pixi/envs/dev/bin/python -m pytest tests/test_live_api.py -v -sDer Live-Test sendet echte Anfragen an den NVIDIA-Endpunkt und verifiziert: automatische Erkennung des Logits-Layers (unembed), echte NPZ-Parsung ((1, seq, 512) float64), Übereinstimmung von evo2_score mit der manuellen Neuberechnung aus den rohen Logits, Varianten-Score.
Projektstruktur
.
├── 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
- 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).632 PyPI2LGPL 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.-
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to query clinical genomics databases, retrieve supporting literature, analyze population genetics, and visualize biological pathways.18MIT