WheatOmics 2.0 · AI & API

Agent & API

WheatOmics opens its wheat multi-omics data to AI agents and scripts: a built-in MCP server for tool-using LLM clients, plus a documented REST API for everything else.

31 MCP tools REST · JSON OpenAPI 3 Copy-ready agent prompt

A · Quick start

How to use the agent

WheatOmics is built to be operated by AI agents. The fastest way to start is to give your assistant — Claude Code, Cursor, VS Code, ChatGPT or any agent that can read a URL or accept pasted text — the ready-to-copy prompt below. The agent reads the live OpenAPI schema and writes a reusable WheatOmics Data Query skill for your own workspace.

Copy-ready prompt

  1. Copy the prompt below.
  2. Paste it into your AI assistant, or attach it as a task in your agent's workspace.
  3. Keep the output — the assistant returns a reusable skill file (for example SKILL.md) plus an optional wheatomics.py helper; load it in later conversations to query the platform directly.
Please read the WheatOmics platform OpenAPI documentation:
https://wheatomics.sdau.edu.cn/api/docs
Machine-readable schema:
https://wheatomics.sdau.edu.cn/api/openapi.json

Based on that documentation, generate a "WheatOmics Data Query" skill for me.

Requirements:
1. Cover every module in the documentation — gene search, expression profiles, sequence retrieval, BLAST, synteny, variation data, literature, and any other module you find.
2. For each module, document its endpoints, parameters, response format, call examples and important notes.
3. Organize the result into a reusable skill file that can be loaded directly in later conversations.
4. Generate everything strictly from the actual endpoint definitions in the OpenAPI document — never invent endpoints that do not exist.
5. Write this hard rule into the skill: whenever an answer involves a specific gene ID, pathway ID (GO/KEGG) or cited reference (PMID/DOI), you MUST call the corresponding API endpoint to verify it in real time. Never rely on memory or guesswork, and never present anything as fact unless it came from an actual API response.
6. Add an "automatic result persistence" convention to the skill: whenever a query produces results the user may want to cite or reproduce later (gene details, expression profiles, BLAST hits, enrichment results, literature, etc.), write them to local files (JSON / Markdown report) by default instead of leaving them only in the conversation. Document the save-to-file usage `wheatomics.py ... -o <file>` and suggest an output directory (for example `./wheatomics_results/`).
Works in any assistant that accepts pasted text. Prefer a native MCP connection instead? See the MCP server section.

What the generated skill contains

  • Every platform module: gene search, expression profiles, sequences, BLAST, synteny, variation data, literature and more.
  • For each module: endpoints, parameters, response format, call examples and notes.
  • A verification rule for gene IDs, GO/KEGG pathway IDs and PMID/DOI references.
  • An output convention that saves query results to JSON / Markdown files.

Why the verification rule matters

WheatOmics identifiers are easy to misremember: one gene ID may exist in several reference genomes, GO/KEGG terms change between releases, and a cited paper may not support the claim it is attached to. The generated skill therefore requires a live API call before any concrete ID or reference is reported — every answer stays traceable to an actual API response instead of model memory.

Read access needs no API key; see access & support for write access and contacts.

B · Model Context Protocol

AI agents: built-in MCP server

WheatOmics runs an MCP (Model Context Protocol) server over stateless Streamable HTTP at /api/mcp — the recommended transport, safe behind the multi-worker production deployment — so an MCP-capable AI client can connect remotely, discover the tools below and call them as native tools. The legacy SSE transport at /api/mcp/sse + /api/mcp/messages remains for single-worker or local-development clients only. The server exposes 31 tools spanning genes and annotation, sequences, expression, networks, comparative genomics, enrichment, literature, reference genomes, JBrowse and BLAST, plus two documentation resources and a copy-ready prompt; the REST API described in the next section covers anything else.

Server and endpoints

Connect to the public host https://wheatomics.sdau.edu.cn:

ItemValue
Server namewheatomics
TransportStreamable HTTP (stateless) — recommended; SSE (legacy)
Streamable HTTP endpoint (recommended)GET/POST/DELETE /api/mcp
SSE endpoint (legacy, single-worker / dev only)GET /api/mcp/sse
Message endpoint (legacy)POST /api/mcp/messages
Tools / resources / prompt31 tools · 2 resources · 1 prompt

Connect an MCP client

Point your MCP client at the stateless Streamable HTTP endpoint. The mcpServers form shown here is what Cursor, VS Code and many other clients use; some clients spell the key servers and accept the transport implicitly, so check your client's schema:

{
  "mcpServers": {
    "wheatomics": {
      "type": "http",
      "url": "https://wheatomics.sdau.edu.cn/api/mcp"
    }
  }
}

Claude Code can register the same server from a shell:

claude mcp add --transport http wheatomics https://wheatomics.sdau.edu.cn/api/mcp

Check connectivity with an MCP initialize JSON-RPC call; the Accept header must allow both a JSON response and an event stream:

curl -sS -X POST https://wheatomics.sdau.edu.cn/api/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize",
       "params":{"protocolVersion":"2025-06-18","capabilities":{},
       "clientInfo":{"name":"curl","version":"1.0"}}}'

Legacy SSE (single-worker / local development only). The original transport is still registered at GET /api/mcp/sse (messages: POST /api/mcp/messages). Use the same client config with "type": "sse" and "url": "https://wheatomics.sdau.edu.cn/api/mcp/sse", or register it with Claude Code:

claude mcp add --transport sse wheatomics https://wheatomics.sdau.edu.cn/api/mcp/sse

Production runs multiple workers that cannot pin an SSE session, so use Streamable HTTP there. Your client must support remote Streamable HTTP MCP servers (or the legacy SSE transport); local stdio-only clients cannot connect to these endpoints directly.

Registered tools

The server registers 31 tools, grouped below by data module. Arguments are passed as the tool input object; required arguments are marked with * and a default value follows =. Errors come back as text rather than raised exceptions, so the model can adjust and retry.

The full JSON input schema of every tool is discoverable through the MCP tools/list request and in the REST API documentation.

Tools whose raw payload would be too large for an agent context (the expression-project and BLAST-database lists) return a compact view by default; set the documented include_* argument to get the full payload.

Sequences & primers 4 tools

ToolKey argumentsWhat it returns / notes
get_sequence_by_gene gene_id * · gene_db=all_gene · protein_db=all_protein Gene and protein FASTA records for one gene ID.
get_sequence_by_interval region * (legacy format, e.g. chr1A:10-100) · database * (a genome database name) FASTA sequence for a genomic interval, via blastdbcmd.
batch_sequence database * · ids * (space-separated gene IDs) Direct-entry FASTA records for many gene IDs in one call.
design_caps_primers seq1 *, seq2 * (same length, one base differs) · mismatch_max=1 (0–3) · top_n=10 Ranked CAPS/dCAPS designs with enzyme, primer sequences, mismatches, cut position and Tm. mismatch_max 0 = CAPS only (natural site), 1–3 = dCAPS.

Genes & annotation 6 tools

ToolKey argumentsWhat it returns / notes
search_known_genes search * · field=all (gene ID, gene name, phenotype, DOI, …) · limit=20 (max 5000) · offset=0 Curated KnownGene hits with phenotype, functional category, species, reference-genome IDs and publications.
get_known_gene gene_id * (gene ID, gene name or numeric clone_id) One curated KnownGene record with structured phenotype, validation-method and publication fields.
get_gene_detail gene_id * (IWGSC v1 / v2 / v3) GeneHub details: genome location, protein length / MW / pI, functional annotations, cross-version IDs and JBrowse / Ensembl links.
resolve_gene_id gene_id * (any annotation version) Chinese Spring 02G mapping for a gene ID from another annotation version.
search_pfam domain * (PFAM ID starting with PF) · table=Genefunc_CS_IWGSC03G_table All genes carrying a PFAM domain (gene-family search); the table selects the annotation.
genes_in_interval region * (e.g. chr5A:587000000..587200000) · table=Genefunc_CS_IWGSC03G_table All genes within a chromosomal interval, with their PFAM / domain annotation column.

Expression & networks 7 tools

ToolKey argumentsWhat it returns / notes
list_expression_projects include_details=false Compact project catalog (id, description, categories, group / subgroup, ~73 KB); call it first to discover valid project values for query_expression. include_details=true returns the raw REST payload with citations and the nested group tree (~600 KB).
query_expression gene_ids * (comma-separated, IWGSC v2.1) · project=PRJEB5314_paired_tbl Expression values and standard deviations for the genes in one project.
query_coexpression gene_ids * (comma-separated) · database=CO_PRJEB25639 · filter_value=300 (PCC threshold when below 1, mutual rank otherwise) Co-expression partners of the input genes, filtered by PCC or mutual rank.
query_ppi gene_ids * (transcript IDs with the .1 suffix) · table=PPI_result · min_score=0.5 Protein-protein interactions from wheatPPI (CF-MS).
list_translatome_datasets — List manifest-driven translatome datasets (id, title, species, tissue, stages, assays, counts, status). The default dataset is the Chen et al. 2025 heat-stress grain translatome.
query_translatome gene_ids * (02G or 03G, comma-separated) · dataset=first visible RNA-seq FPKM, Ribo-seq FPKM and TE (manifest-driven stages/treatments). Returns both 02G and 03G IDs; TE is null when RNA-seq FPKM < 0.2.
list_translatome_dtgs dataset=first visible · stage=5DAA · direction=both · cluster · gene · per_page=10 Differentially translated genes (11,343 DTG; RiboDiff FDR < 0.05, |log2FC| > 1) with cluster, Padj and log2FC.

Comparative & variation 4 tools

ToolKey argumentsWhat it returns / notes
find_homologs gene_id * (wheat or another species) · max_targets=3 (per species, 1–50) Rice and Arabidopsis homologs with Qcovs, identity, E-value and score.
search_synteny query * (gene ID or interval, e.g. chr5A:100000-200000) · table=CSsymaptbl Synteny relationships between Chinese Spring and durum wheat, wild emmer, T. urartu and Ae. tauschii.
convert_gene_ids gene_ids * (transcript IDs with .1, newline- or space-separated) · version * (MIPS_result · TGACv1_result · IWGSCv1_result) Transcript IDs converted to IWGSC v1.1 (02G).
search_eqtl gene * (e.g. TraesCS5A02G391700) eQTL records for the gene, plus each project's FarmCPU Manhattan-plot information.

Enrichment & literature 4 tools

ToolKey argumentsWhat it returns / notes
go_enrichment genes * (array of gene IDs) · padj_threshold=0.05 GO terms enriched by hypergeometric test with Benjamini-Hochberg FDR.
kegg_enrichment genes * (array of gene IDs) · padj_threshold=0.05 KEGG pathways enriched by hypergeometric test with Benjamini-Hochberg FDR.
search_papers q, title, abstract, journal, authors, pubmed_keywords, gene_name, pmid, pub_date_start, pub_date_end, since_days (all optional) · limit=20 (max 200) · offset=0 Triticeae literature hits (12K+ papers); verify PMID / DOI claims with get_paper before citing.
get_paper pubmedid * One paper record with the metadata needed to verify a citation.

Genomes, JBrowse & BLAST 6 tools

ToolKey argumentsWhat it returns / notes
list_genomes ploidy, annotation_status, has_annotation, q, include_hidden=false, limit=100, offset=0 (all optional) Reference genomes with assembly metadata, ploidy and annotation status.
get_genome dataset_id * One genome record: assembly, ploidy, annotation and download links.
list_jbrowse_datasets — JBrowse datasets and their track counts, for genome-browser links.
submit_blast database * (comma-separated, max 20) · query * (FASTA) · program=blastp · evalue=10.0 · max_target_seqs=1000 · word_size · matrix · outfmt=tabular A job_id immediately — BLAST is always asynchronous; poll get_blast_status. Call list_blast_databases first to discover valid database names.
get_blast_status job_id * Job state (pending / running / done / error / stale) and download links when finished.
list_blast_databases program (optional) · include_databases=false · include_metadata=false Compact summary (~12 KB): all protein database names, a sample of nucleotide names and per-category counts. include_databases=true returns every database name (~105 KB); include_metadata=true the full REST payload with per-database metadata (~600 KB).

Resources and prompt

Beyond tools, the server publishes two read-only documentation resources and one prompt over the same MCP connection, so an agent can load the platform guide without extra requests to the REST API:

ItemURI / nameContents
Resource wheatomics://docs/modules
application/json
JSON module and tool catalog: every platform module, its REST prefix, the MCP tools that cover it, and the total tool count.
Resource wheatomics://docs/agent-guide
text/markdown
Markdown guide: endpoints, tool conventions, the mandatory live-verification rule and the result-persistence convention.
Prompt generate_wheatomics_skill
no arguments
The copy-ready prompt from the How-to section, served through prompts/get so a client can offer it as a one-click action.

Clients list and read these with the standard MCP resources/list, resources/read, prompts/list and prompts/get requests; there is nothing to install or configure beyond the SSE connection above.

C · Representational State Transfer

REST API

Every data module is also reachable over plain HTTP under the base URL https://wheatomics.sdau.edu.cn/api. The interactive references are the quickest way to explore the endpoints: Swagger UI, the ReDoc reference, or the machine-readable OpenAPI 3.x schema.

Response envelope

Successful calls are wrapped consistently, with the payload under data:

{
  "success": true,
  "message": "ok",
  "timestamp": "2026-10-29T02:15:00+00:00",
  "data": { }
}

The timestamp is regenerated on every response. Validation errors (HTTP 422) and unexpected server errors (HTTP 500) return the same envelope with "success": false, an error summary and a detail field; endpoints can also answer with a plain HTTP error status and a detail message.

Quick start

Application metadata:

curl https://wheatomics.sdau.edu.cn/api/about

It returns the API name, version, docs, api_prefix, server_time and client_ip.

One page of the curated known-gene list:

curl "https://wheatomics.sdau.edu.cn/api/genes/known/all?limit=2"

GET /api/genes/known/all accepts optional limit (1–5000) and offset (≥ 0); without limit it returns the full list.

Main API modules

These are the main module prefixes; the Swagger UI and ReDoc pages list every path and parameter in full.

ModulePrefixModulePrefix
Known Genes/api/genes/knownCo-expression/api/coexpression
GeneHub/api/genes/detail/{gene_id}WheatPPI/api/ppi
PfamSearch/api/genes/functions/pfamComparative/api/comparative
IntervalTool/api/genes/functions/intervalTriticeae Papers/api/papers
Sequences/api/sequenceGO / KEGG/api/go · /api/kegg
BLAST/api/blastVariantHub/api/VariantHub
Expression/api/expressioneQTL Atlas/api/eqtl
OrthoFinder/api/orthofinderCAPS / dCAPS/api/caps
JBrowse/api/jbrowsePrimerServer2/api/PrimerServer2

Long-running BLAST jobs

BLAST is asynchronous: POST /api/blast/search queues a job (form fields such as program, database and query), and GET /api/blast/status/{job_id} reports the status and download links. Send wait=false to get a job_id back immediately instead of waiting for the result.

Why this matters for agents

Give an LLM the OpenAPI JSON — or connect the MCP server — and it can discover the available data endpoints and call them on its own. Responses are already machine-friendly JSON under the unified envelope, so no scraping or ad-hoc parsing is needed.

D · Access & support

Access & support

Access

All read endpoints are public and need no API key. Write endpoints — such as the curated known-gene write API at /api/genes/known/write — require an API key issued by the maintainers; the key is sent in the Authorization: Bearer or X-API-Key header.

Keys are scoped, rate-limited and audited, and are only issued for curation work. Email shengweima@icloud.com to request one or to report a problem.

Support

Questions, bug reports and feature requests are welcome by email at shengweima@icloud.com.

See the contact page for the project team and the news page for updates about the platform and its data releases.

Cite WheatOmics through the platform citation on the homepage. This page was last updated on 2026-10-29 and describes the 31-tool MCP server, its resources and prompt, the REST API and the copy-ready agent prompt as deployed at that time.