genomic-intelligence
Predict regulatory features, gene structure, and expression directly from DNA sequence using Genomic Intelligence's hosted transformer DNA language models — no local GPU or model weights. Six tasks over a REST API and a hosted MCP server (keyless public demo): promoter regions, splice donor/acceptor sites, enhancer activity, chromatin state, sequence-to-expression (log TPM), and de-novo gene annotation, plus a composite find-genes-then-predict-expression workflow. Use when the user has a gene symbol, a genomic region, or a DNA/FASTA sequence and wants any of these predictions, mentions Genomic Intelligence, genomicintelligence.ai, api.genomicintelligence.ai, or mcp.genomicintelligence.ai.
- License 许可
- MIT
- 最近更新
- 2026-10-22
- Stars
- ★ 0
- Forks
- 0
01 前言 Front Matter
- name
- genomic-intelligence
- license
- MIT
- metadata
- { "version": "1.0", "openclaw": { "envVars": [ { "name": "GI_API_KEY", "required": false, "description": "Optional gi_ bearer key for the REST /v1 API and a higher MCP quota. The hosted MCP demo runs keyless; request a key at contact@genomicintelligence.ai." } ], "primaryEnv": "GI_API_KEY" }, "skill-author": "Genomic Intelligence", "trigger-keywords": "DNA sequence prediction, regulatory genomics, promoter prediction, splice site prediction, enhancer activity, chromatin state, gene expression prediction, sequence to expression, log TPM, gene annotation, transcript prediction, DNA language model, genomic intelligence, hosted inference, Ensembl sequence, FASTA prediction, cis-regulatory, TSS window, DeepSEA, DeepSTARR, BigBird splice, MCP genomics" }
- description
- Predict regulatory features, gene structure, and expression directly from DNA sequence using Genomic Intelligence's hosted transformer DNA language models — no local GPU or model weights. Six tasks over a REST API and a hosted MCP server (keyless public demo): promoter regions, splice donor/acceptor sites, enhancer activity, chromatin state, sequence-to-expression (log TPM), and de-novo gene annotation, plus a composite find-genes-then-predict-expression workflow. Use when the user has a gene symbol, a genomic region, or a DNA/FASTA sequence and wants any of these predictions, mentions Genomic Intelligence, genomicintelligence.ai, api.genomicintelligence.ai, or mcp.genomicintelligence.ai.
- compatibility
- Python 3.10+ with the `requests` library for the REST path (no dedicated SDK). Network access required. The REST `/v1` API needs a `GI_API_KEY` (a `gi_` bearer); the hosted MCP server at mcp.genomicintelligence.ai/mcp works keyless against a capped public demo quota, key optional.
02 资源文件 4
- 参考文档references/api-and-auth.md1.7 KB
- 参考文档references/mcp.md3.8 KB
- 参考文档references/sequence-acquisition.md2.3 KB
- 参考文档references/tasks.md3.6 KB
03 SKILL.md 正文
Genomic Intelligence — DNA Sequence Models
Genomic Intelligence (GI) serves transformer DNA language models over six sequence-analysis tasks on managed GPUs. Give it a gene symbol, a genomic region, or a DNA/FASTA sequence; it returns structured predictions — promoter regions, splice sites, enhancer activity, chromatin state, expression (log TPM), and de-novo gene annotation. Nothing runs locally: no model weights, no GPU, no heavy Python stack. It is a thin client over a hosted, versioned inference API.
Official docs: docs.genomicintelligence.ai ·
REST contract at api.genomicintelligence.ai/v1/openapi.json ·
hosted MCP server at https://mcp.genomicintelligence.ai/mcp
When to use this skill
Use GI when the user has DNA and wants a model prediction:
- Find promoters in a genomic region (
promoter) - Predict splice donor/acceptor sites (
splice) - Score enhancer activity — developmental & housekeeping (
enhancer) - Annotate chromatin state across hundreds of tracks (
chromatin) - Predict expression as log(TPM+1) from a sequence + cell-type context (
expression) - Annotate genes/transcripts de novo, no reference needed (
annotation) - Find the genes in a region and predict each one's expression (composite)
Not for local alignment, variant calling, or file I/O — use a local tool (BioPython, bcftools) for those. GI is for model inference from sequence.
For research and development use, not clinical or diagnostic decisions.
Two ways to call GI
Hosted MCP server (best for AI agents — keyless)
GI hosts an MCP server at https://mcp.genomicintelligence.ai/mcp (Streamable
HTTP). When your agent host supports MCP, prefer it: it works keyless against
a capped public demo quota (zero setup), and an optional gi_ bearer key raises
the quota. It exposes acquisition tools that return a sequence handle
(sequence_ref) and predict_* tools that take that handle — so large sequences
never bloat the context. See MCP workflow below and
references/mcp.md.
REST API (universal)
Plain HTTP with requests against https://api.genomicintelligence.ai/v1. The
REST path requires a GI_API_KEY (a gi_ bearer). Use it on any host, in
scripts, or when you need the raw envelope. See Core REST workflow.
Access and authentication
- The hosted MCP demo is keyless — try it with nothing set.
- The REST
/v1API needs a key, sent asAuthorization: Bearer <key>. Request one at contact@genomicintelligence.ai. - Never hardcode the key. Read it from the
GI_API_KEYenvironment variable (or a.envviapython-dotenv). Never commit keys.
export GI_API_KEY="gi_yourkeyhere" # optional for MCP; required for REST
export GI_BASE_URL="https://api.genomicintelligence.ai" # override for staging
Keys are scoped to a partner tier with concurrency and per-minute caps. A 429
means you hit a cap — back off and retry, or ask GI to raise your tier.
The six tasks
All REST tasks share one shape: POST /v1/tasks/{task}/predict with body
{sequence, sequence_name, model?, options?}, returning a {data, meta}
envelope. What differs per task:
| Task | Mode | Length bound | Notes |
|---|---|---|---|
promoter |
sync | 1–500,000 bp | sliding-window promoter regions |
splice |
sync | 1–500,000 bp | donor/acceptor sites (long-context BigBird) |
enhancer |
sync | 1–500,000 bp | dev + housekeeping scores (DeepSTARR, Drosophila) |
chromatin |
sync | 1–500,000 bp | hundreds of tracks (DeepSEA) |
expression |
sync | exactly 9,198 bp | log(TPM+1); needs a cell-type description |
annotation |
async | 1–500,000 bp | de-novo transcripts; submit + poll |
Omit model and the API uses the task's default — that is the recommended
call. Default model IDs are intentionally not documented here: defaults
change and retired IDs fail hard, so never hardcode one. To pin a model, or to
pick a non-human one (Drosophila, yeast, and Arabidopsis models exist for several
tasks), discover IDs at call time with GET /v1/tasks/{task}/models (REST) or
list_models (MCP) — and never invent one. Full per-task output shapes are
in references/tasks.md.
Two hard rules the model enforces:
expressionneeds exactly 9,198 bp, a window centred on the TSS (4,599 upstream + TSS + 4,598 downstream). Any other length is rejected. Use the acquisition helpers below to build it — do not truncate by hand.expressionneeds adescription— a cell-type / assay string (e.g."K562 cells"), passed asoptions.description.
Sequence acquisition
You rarely start from a raw 9,198 bp string. Acquire sequence first:
- From a gene symbol → MCP
fetch_ensembl_sequence(gene=...); from coordinates →fetch_region(region=...). Both fetch public Ensembl reference sequence (no key). REST users can query Ensembl REST directly. (find_genesis the annotation task, not an acquisition tool.) - For
expression→ use the TSS-centred fetch so the window is exactly 9,198 bp. MCP:fetch_gene_for_expression(handles the centring). Do not build the window by hand. - From a local FASTA → MCP
store_inline_sequence, or read the file yourself for REST. (load_local_fastaexists only in local deployments, not on the hosted server.) - A demo sequence → MCP
load_demo_sequence(name=...)returns a ready handle (great for a keyless smoke test);nameis required.
See references/sequence-acquisition.md for the exact Ensembl calls and the
expression-window math.
Core REST workflow
Sync tasks (promoter, splice, enhancer, chromatin, expression) are one call:
import os, requests
BASE = os.environ.get("GI_BASE_URL", "https://api.genomicintelligence.ai")
HEADERS = {"Authorization": f"Bearer {os.environ['GI_API_KEY']}"}
def predict(task, sequence, sequence_name, model=None, options=None):
body = {"sequence": sequence, "sequence_name": sequence_name}
if model: body["model"] = model
if options: body["options"] = options
r = requests.post(f"{BASE}/v1/tasks/{task}/predict", headers=HEADERS, json=body)
r.raise_for_status() # 400 invalid; 401 no/bad key; 413 too long; 429 rate limit
return r.json() # {"data": {...}, "meta": {...}}
# Promoter:
out = predict("promoter", seq, "TP53_region")
print(out["data"]["summary"])
# Expression — exactly 9,198 bp + a cell-type description:
out = predict("expression", tss_window_9198bp, "HBB",
options={"description": "K562 cells"})
print(out["data"]["prediction"]["expression_log_tpm"])
Async: annotation
annotation is submit-then-poll. Send Prefer: respond-async, get a job_id,
poll until terminal:
import time
r = requests.post(f"{BASE}/v1/tasks/annotation/predict",
headers={**HEADERS, "Prefer": "respond-async"},
json={"sequence": seq, "sequence_name": "TP53"})
r.raise_for_status() # 202 Accepted
job_id = r.json()["data"]["job_id"]
while True:
j = requests.get(f"{BASE}/v1/tasks/jobs/{job_id}", headers=HEADERS)
if j.status_code == 200: # terminal: body is the final {data, meta}
break
j.raise_for_status() # 202 = still running (2xx, won't raise)
time.sleep(5) # ~20 s typical for ~20 kb
transcripts = j.json()["data"]["transcripts"]
MCP workflow (handle-based)
On an MCP host, acquire a handle, then predict against it — sequences stay out of the context:
# 1. Acquire a sequence handle (each returns a sequence_ref):
load_demo_sequence(name="promoter_tp53") # keyless smoke test; `name` is REQUIRED
fetch_ensembl_sequence(gene="TP53") # gene symbol or Ensembl ID -> handle
fetch_region(region="chr11:5,225,000-5,235,000") # coordinates -> handle
fetch_gene_for_expression(gene="HBB") # TSS-centred 9,198 bp handle for expression
# 2. Predict against the handle:
predict_promoter(sequence_ref=<ref>)
predict_expression(sequence_ref=<ref>, description="K562 cells")
predict_splice(sequence_ref=<ref>) # + predict_enhancer / predict_chromatin
# 3. Annotation on MCP is `find_genes` (there is no predict_annotation).
# It takes a handle, not a region, and runs async internally:
find_genes(sequence_ref=<ref>) # wait=True (default) returns the result
find_genes(sequence_ref=<ref>, wait=False) # -> job_id; poll get_job(job_id)
# Discover models with list_models(task); reference context lives in the
# gi://models, gi://docs/tasks, and gi://account MCP resources.
Composite: find genes, then predict expression
To answer "what genes are in this region and how are they expressed?", use the composite:
- MCP:
find_genes_and_predict_expression(sequence_ref=..., description=...)— takes a handle, not a region (acquire one withfetch_regionfirst);descriptionis required. Finds genes in the sequence and returns an expression prediction for each. - REST: call gene discovery, then loop
expressionper gene (build each TSS-centred 9,198 bp window via the acquisition helpers).
Errors
| Code | Meaning | Action |
|---|---|---|
| 400 | Invalid request / bad sequence | Check the body; expression must be exactly 9,198 bp and carry description |
| 401 | Missing/invalid key (REST) | Set GI_API_KEY; or use the keyless MCP demo |
| 413 | Sequence too long | Stay within the task's length bound (≤500,000 bp) |
| 429 | Rate / concurrency cap | Back off and retry; ask GI to raise your tier |
| 422 | Validation failed (validation_failed) |
The most common failure: expression not exactly 9,198 bp, or a sequence below the model's minimum length |
| 5xx | Server error | Retry; if persistent, contact support |
Reference files
references/tasks.md— per-task output shapes, model registries, the async annotation contract.references/api-and-auth.md— REST endpoints, the{data, meta}envelope, auth, base-URL override, tiers.references/mcp.md— the hosted MCP tool list, the handle-based flow, and thegi://resources.references/sequence-acquisition.md— Ensembl fetch calls and the expression-window (9,198 bp, TSS-centred) math.
04 同仓库更多 Skills
zarr-python
Chunked N-D arrays for cloud storage (Zarr-Python 3). Compressed arrays, parallel I/O, S3/GCS via fsspec, NumPy/Dask/Xarray compatible, for large-scale scientific computing pipelines.
video-use
Edit any video by conversation. Transcribe, cut, color grade, generate overlay animations, burn subtitles — for talking heads, montages, tutorials, travel, interviews. No presets, no menus. Ask questions, confirm the plan, execute, iterate, persist. Production-correctness rules are hard; everything else is artistic freedom.
venue-templates
Prepare journal manuscripts, conference papers, research posters, and grant documents using venue-specific formatting guidance and bundled LaTeX scaffolds. Use when selecting an official template, checking current page or anonymity rules, adapting academic writing to a venue, or inspecting a submission PDF.
vaex
Use this skill for processing and analyzing large tabular datasets (billions of rows) that exceed available RAM. Vaex excels at out-of-core DataFrame operations, lazy evaluation, fast aggregations, efficient visualization of big data, and machine learning on large datasets. Apply when users need to work with large CSV/HDF5/Arrow/Parquet files, perform fast statistics on massive datasets, create visualizations of big data, or build ML pipelines that do not fit in memory.
usfiscaldata
Query the U.S. Treasury Fiscal Data REST API for federal financial data. No API key required. Use for national debt (Debt to the Penny), Daily Treasury Statements, Monthly Treasury Statements, Treasury securities auctions, interest rates, foreign exchange rates, savings bonds, or U.S. government revenue and spending statistics.
uncertainty-and-units
Track physical units and propagate measurement uncertainty in scientific calculations using pint and uncertainties. Use for unit conversion and dimensional checking, GUM uncertainty budgets, Type A and Type B evaluation, coverage factors and expanded uncertainty, Monte Carlo propagation, significant-figure and plus-minus reporting, error propagation through curve fits, CODATA constants, auditing Python code for stripped units or broken uncertainty propagation, and order-of-magnitude plausibility checks using dimensionless groups (Reynolds, Peclet, Damkohler, Knudsen, Biot, Womersley), characteristic scales such as diffusion time or Debye length, and observed magnitude ranges. Trigger on "is this number physically reasonable", "sanity check these units", "what regime is this flow in", or a result that looks off by orders of magnitude.