Genomic Intelligence
Hosted DNA language models: promoter, splice, enhancer, chromatin, expression, annotation
| Endpoint | https://mcp.genomicintelligence.ai/mcp (streamable-http) |
|---|---|
| Registry version | 1.0.0 |
| Now | 15 tools · grade D (50) · pin ts_584278eb5858e0ef874c44bc8b2c0e17 · protocol 2025-06-18 |
| First / last listed | 2026-11-02 01:49 UTC / 2026-11-02 01:49 UTC |
| Grade over time | 2026-11-02: D (50), 15 tools |
Is this your server? Own a server? ToolFit hosted watch re-checks it every 24 h ($0.25 per 30 days) or 6 h ($0.60) and sends you an HMAC-signed webhook when its tools or grade change: POST https://api.youraitools.co/toolfit/v1/watch. To opt out, see About & opt-out.
Tools: list_models fetch_ensembl_sequence fetch_region fetch_gene_for_expression load_demo_sequence store_inline_sequence predict_promoter predict_splice predict_enhancer predict_chromatin predict_expression find_genes find_genes_and_predict_expression get_job list_jobs
list_models | List available models for a task.
Use to discover model ids before passing one as the `model`
argument to a predict tool. The same catalog is also available
as the resource `gi://models`.
Returns a FLAT object — {task, default_model, models: [...]} — not the
{data, meta} envelope the predict tools return. Each model carries a
`bio_spec`, whose usef params: task* |
fetch_ensembl_sequence | Fetch a gene's reference sequence from Ensembl and store it.
Returns a handle ({ref, name, length, preview, ...}). Pass the
`ref` to predict_* tools — the bases stay server-side. For
expression, use fetch_gene_for_expression instead (it prepares
the TSS-centred window that model needs).
params: gene*, species, flank_bp |
fetch_region | Fetch a genomic region by coordinates from Ensembl and store it.
For "find the genes in chr8:127,680,000-127,800,000"-style requests:
resolves a coordinate range to reference sequence and returns a handle
({ref, name, length, ...}) to pass to find_genes / predict_* — the bases
stay server-side. Plus strand by default, which is what the gene-finder
expects. params: region*, species, strand, flank_bp |
fetch_gene_for_expression | Fetch a gene's sequence prepared for expression prediction.
Resolves the gene's canonical-transcript TSS via Ensembl and stores a
gene-sense sequence centred on it, as a handle to pass to
predict_expression(sequence_ref=...). Longer TSS-centred sequence
gives better predictions, so this already fetches as much flank on
each side of the TSS as the listed exp params: gene*, species |
load_demo_sequence | Load a bundled demo reference sequence and return a handle.
The server ships one curated, task-correct positive control per task
(list them via the gi://sequences resource) — e.g.
`expression_hbb_k562` is a ready-to-use K562 expression window for
predict_expression. Stores the demo and returns a handle to pass to a
predict_* tool: no Ensembl fetch, no quota params: name* |
store_inline_sequence | Store a human-pasted sequence and return a handle to re-use it.
For a sequence you've already pasted into the conversation, this
gives back a short handle so you can run several tasks on it
without re-pasting the bases in each predict_* call. Note that the
full sequence still passes through the LLM on THIS call — it does
not save context on its own. For lar params: sequence*, name |
predict_promoter | Predict promoter regions (G0). 300–500,000 bp.
Returns the {data, meta} envelope: data.regions lists predicted
promoters with start/end/score.
300 bp is the task floor for every promoter model. The default
g0-promoter-2000bp scans a 2,000 bp context window, so a shorter
(but ≥300 bp) sequence is still scored — against a window padded out
to that si params: sequence, sequence_ref, sequence_name, model |
predict_splice | Predict splice donor/acceptor sites (G0 BigBird). 100–500,000 bp.
The model reads a 15,000 bp context window, so anything shorter is
scored against a padded window — feed a whole transcript locus when you
can. It is also strand-specific, and the wrong strand fails silently and
plausibly — it returns sites at different positions, often still scoring
above 0. params: sequence, sequence_ref, sequence_name, model |
predict_enhancer | Predict enhancer activity (G0 DeepSTARR). 50–500,000 bp.
50 bp is the task's admission floor (the API 422s below it), not a
statement about what the model reads: enhancer models score a 249 bp
context window, so 50–248 bp is accepted and scored against a padded
window. For a meaningful call, submit at least the 249 bp context.
params: sequence, sequence_ref, sequence_name, model |
predict_chromatin | Chromatin annotation across 919 features (G0 DeepSEA). 200–500,000 bp.
The model reads a 1,000 bp context window; 200–999 bp is accepted and
scored against a padded window.
params: sequence, sequence_ref, sequence_name, model |
predict_expression | Predict a gene's expression from the sequence around its TSS.
Expression is cell-type-specific, so `description` (cell type /
assay context, e.g. 'K562 cell line') is REQUIRED — the API
rejects requests without it.
The input rule is the same for every expression model: at least
9,198 bp, with the TSS at least 4,599 bp from each end, up to
500,000 b params: sequence, sequence_ref, description, tss_index, sequence_name, model |
find_genes | Find genes (transcript intervals) in a genomic region (async, ~8-25s).
Takes 1,000–500,000 bp. The floor is the strictest of the scanning
tasks: gene finding needs a region, not a site. (Only expression's
9,198 bp is higher, and that is the sequence around one TSS rather
than a region to search.)
Gene-finding: detects transcript boundaries (TSS + PolyA) an params: sequence, sequence_ref, sequence_name, model, wait |
find_genes_and_predict_expression | Find genes in a sequence, then predict each gene's expression (composite).
Server-side chaining in ONE call: finds genes (transcript intervals,
with their TSS) in the sequence, then predicts expression off each
discovered TSS in the given experimental context. This is the right
tool whenever you want expression for a raw region or sequence — e.g.
"find the params: sequence, sequence_ref, description, sequence_name, wait |
get_job | Poll an async job once.
Returns the {data, meta} result if complete, a progress envelope
if still running, or an error envelope if it failed.
params: job_id* |
list_jobs | List the caller's recent async jobs (also available as gi://jobs/recent). params: limit |
Entries describe changes in tool definitions. They are not statements about a server, its quality or its author. The grade measures how the tool definitions fit model providers (token cost, schema compatibility, confusable names) as scored by the ToolFit engine at the time of the listing. JSON: append .json. Opt-out: how or hello@youraitools.co.