Connector operation reference

Look up exact operation names, required fields, defaults and example calls. To choose a data source, start with the database catalog. Expand the Connector family you intend to call; availability and credentials must be configured separately.

Where the example calls run

The host object is supplied by Open-Science's agent execution environment. The JavaScript below is an agent-side call fragment, not a standalone Node.js program and not a method on the public Task SDK client. Ask the agent to load the relevant Connector instructions and use the matching operation. A framework may expose a Python bridge instead of this JavaScript form.

First enable the Connector in Settings → Connectors, configure any required credentials, and grant access to the selected Specialist if applicable. The call still follows the conversation's permission policy. Public Node.js integrations can manage Connector settings with the Task SDK, but cannot obtain this host by importing that client.

Read a result before chaining calls

Example Pass returned PubMed IDs to a metadata lookup

For example, ask: Use PubMed to search for PRISMA reporting guidance; return the total match count and five PMIDs. The operation search_articles returns a total and a page of identifiers. Feed those returned PMIDs to get_article_metadata to obtain titles, authors and DOI links. An empty page, a truncated result and an authentication error need different handling.

Returned information	Use it for
Total match count and returned rows	Distinguish a small page from the complete result set
truncated, records_truncated or family-specific completeness flags	Decide whether to page, narrow the query or retrieve the rest
not_found, missing, not_processed	Identify unresolved inputs and retry only appropriate items
DOI, accession, source URL and release/build	Retain the identity and source needed for subsequent queries
Full-text status or license note	Decide whether text was retrieved and can be reused

Return field names differ by operation. The descriptions and downloadable schemas below specify each contract; the table is not a universal JSON response. Use the right-hand family list to jump, then expand that family's parameters. Searching for an operation name also opens its containing group.

Read failures separately from empty results. In v0.30.2, CellGuide marker/source/tissue requests surface fetch failures instead of treating them as empty evidence; an absent optional data file can still be empty. OLS relation queries reject incomplete pagination and invalid responses. A service error is not evidence that a cell type has no markers or an ontology term has no related terms.

Operation inputs

Expand one Connector at a time. Required fields are marked required; this reference and download use the Open-Science v1.0.5 schema. A nested input.required list is authoritative; a legacy top-level required list may be absent. Consult the complete downloadable registry for nested JSON schemas, full return descriptions and agent-side call examples. Do not pass a generic id when a tool expects accessions, cids, rs_id or another namespace-specific field.

Chemistry

Show operations and parameters

pubchem_search_compounds

Resolve a chemical identifier (name, SMILES, InChIKey, or CID) to PubChem CIDs, optionally with core computed properties for the top hits.

Field	Type	Requirement and constraints
query	string	required
namespace	string	optional; default: "name"; enum: ["name", "smiles", "inchikey", "cid"]
max_cids	integer	optional; default: 25; minimum: 1; maximum: 100
with_properties	boolean	optional; default: true

const result = await host.mcp("chemistry", "pubchem_search_compounds", {"query": "aspirin", "max_cids": 25})

pubchem_get_compounds

Full computed-property records for a batch of PubChem CIDs, with optional capped synonym lists.

Field	Type	Requirement and constraints
cids	array of integer	required; minItems: 1; maxItems: 50
include_synonyms	boolean	optional; default: false
max_synonyms	integer	optional; default: 30

const result = await host.mcp("chemistry", "pubchem_get_compounds", {"cids": [2244, 2519], "include_synonyms": false})

pubchem_similarity_search

2D Tanimoto similarity search over all of PubChem for a query SMILES (synchronous fastsimilarity_2d route, no job polling).

Field	Type	Requirement and constraints
smiles	string	required
threshold	integer	optional; default: 90; minimum: 1; maximum: 100
max_records	integer	optional; default: 50; minimum: 1; maximum: 200
with_properties	boolean	optional; default: false

const result = await host.mcp("chemistry", "pubchem_similarity_search", {"smiles": "CC(=O)OC1=CC=CC=C1C(=O)O", "threshold": 90})

pubchem_get_bioassay_summary

Bioassay activity summary for one PubChem compound — which assays tested it, against which targets, with what outcome and potency.

Field	Type	Requirement and constraints
cid	integer	required
active_only	boolean	optional; default: false
max_rows	integer	optional; default: 100; minimum: 1; maximum: 1000

const result = await host.mcp("chemistry", "pubchem_get_bioassay_summary", {"cid": 2244, "active_only": true})

pubchem_get_safety

GHS safety classification for one PubChem compound (PUG-View 'GHS Classification' heading), aggregated across reporting sources.

Field	Type	Requirement and constraints
cid	integer	required

const result = await host.mcp("chemistry", "pubchem_get_safety", {"cid": 702})

chebi_search

Full-text search over ChEBI entities (names, synonyms, formulae, InChIKeys).

Field	Type	Requirement and constraints
term	string	required
max_results	integer	optional; default: 20; minimum: 1; maximum: 100
page	integer	optional; default: 1; minimum: 1

const result = await host.mcp("chemistry", "chebi_search", {"term": "caffeine", "max_results": 20})

chebi_get_entity

Full ChEBI entity record: names, structure, chemical data, roles and cross-references.

Field	Type	Requirement and constraints
chebi_id	string	required
max_synonyms	integer	optional; default: 30
max_xrefs	integer	optional; default: 50

const result = await host.mcp("chemistry", "chebi_get_entity", {"chebi_id": "CHEBI:27732"})

chebi_get_ontology

Ontology relations of a ChEBI entity — what it IS (outgoing: is a / has role / conjugate acid...) and what points AT it (incoming: children/derivatives).

Field	Type	Requirement and constraints
chebi_id	string	required
relation_type	string	optional
max_relations	integer	optional; default: 100

const result = await host.mcp("chemistry", "chebi_get_ontology", {"chebi_id": "CHEBI:27732", "relation_type": "has role"})

rhea_search_reactions

Search Rhea master reactions by equation text, participant ChEBI id, or EC number (query type auto-detected).

Field	Type	Requirement and constraints
query	string	required
limit	integer	optional; default: 50; minimum: 1; maximum: 500

const result = await host.mcp("chemistry", "rhea_search_reactions", {"query": "caffeine", "limit": 50})

rhea_get_reaction

Full record for one Rhea reaction: equation, participants with ChEBI ids and stoichiometry, EC links, direction family and literature.

Field	Type	Requirement and constraints
rhea_id	string	required

const result = await host.mcp("chemistry", "rhea_get_reaction", {"rhea_id": "10280"})

bindingdb_ligands_by_target

Measured binding affinities (Ki/Kd/IC50/EC50) of all BindingDB ligands against one protein target, by UniProt accession.

Field	Type	Requirement and constraints
uniprot	string	required
affinity_cutoff_nm	number	optional; default: 10000
max_rows	integer	optional; default: 100; minimum: 1; maximum: 1000

const result = await host.mcp("chemistry", "bindingdb_ligands_by_target", {"uniprot": "P00533", "affinity_cutoff_nm": 100})

bindingdb_targets_by_compound

Protein targets with measured affinities for compounds 2D-similar to a query SMILES — "what does this molecule (or its close analogs) bind?".

Field	Type	Requirement and constraints
smiles	string	required
similarity	number	optional; default: 0.85; minimum: 0.5; maximum: 1
max_rows	integer	optional; default: 100; minimum: 1; maximum: 1000

const result = await host.mcp("chemistry", "bindingdb_targets_by_compound", {"smiles": "CC(=O)OC1=CC=CC=C1C(=O)O", "similarity": 0.85})

lipidmaps_get_compound

Look up lipid classification and compound details in LIPID MAPS by one exact LMID or PubChem CID. Resolve names with PubChem first. Returns native structure identifiers and available database mappings; missing fields remain unknown. An LMID may describe a generic or incompletely specified structure, not a unique experimentally identified molecule. Preserve all returned matches rather than selecting the first. No name, formula, abbreviation, mass or bulk search. Data: LIPID MAPS, CC BY 4.0; retain attribution and record links.

Field	Type	Requirement and constraints
id_type	string	required; enum: ["lm_id", "pubchem_cid"]
identifier	string	required; maxLength: 15

const result = await host.mcp("chemistry", "lipidmaps_get_compound", {"id_type": "lm_id", "identifier": "LMFA01010001"})

unichem_map_compound

Map one exact full InChIKey or ChEMBL ID to PubChem, ChEMBL and ChEBI identifiers using UniChem. Resolve names with PubChem first. Preserves distinct matched structures and reports filtering and truncation. Mapping reflects UniChem indexed assignments, not verified current source records or biological equivalence. No name, similarity, connectivity, salt-component or batch search.

Field	Type	Requirement and constraints
id_type	string	required; enum: ["inchikey", "chembl"]
identifier	string	required; maxLength: 27

const result = await host.mcp("chemistry", "unichem_map_compound", {"id_type": "chembl", "identifier": "CHEMBL1089"})

Literature Graph

Show operations and parameters

openalex_search_works

Search OpenAlex scholarly works (all disciplines, ~250M records) with year/type/OA/venue filters. Args: query (free-text over title+abstract+fulltext; optional if a filter is set), year_from, year_to (inclusive years), work_type (article/review/preprint/book-chapter/dataset/dissertation), open_access_only, venue (S-id, openalex.org URL, ISSN, or a plain name resolved to the top sources hit — surfaced in venue_resolved; pass an exact ID to skip resolution), sort (relevance default / cited_by_count / publication_date), max_records (default 50, hard ceiling 500; pages of 200), include_abstracts (reconstructed from the inverted index, but ONLY for verified-open licenses — cc-by/cc-by-sa/cc0/public-domain; others get abstract=null + abstract_policy note + abstract_license; adds bulk). Returns {query, filters, sort, api_total, n_records_returned, records_truncated, records}; each record is the lean work shape (openalex_id, doi, pmid, title, publication_year/date, type, language, is_retracted, authors[...], source{...}, biblio, cited_by_count, fwci, referenced_works_count, open_access{...}, best_oa_pdf_url, primary_topic, keywords).

Field	Type	Requirement and constraints
query	string	optional
year_from	integer	optional
year_to	integer	optional
work_type	string	optional
open_access_only	boolean	optional
venue	string	optional
sort	string	optional; default: "relevance"; enum: ["relevance", "cited_by_count", "publication_date"]
max_records	integer	optional; default: 50
include_abstracts	boolean	optional; default: false

const result = await host.mcp("literature", "openalex_search_works", {"query": "CRISPR base editing", "year_from": 2020, "open_access_only": true, "sort": "cited_by_count", "max_records": 25})

openalex_get_work

Fetch one OpenAlex work in full — metadata, abstract (reconstructed from the inverted index, license-gated as in openalex_search_works), OA locations, referenced_works (outgoing W-ids — hydrate with openalex_references) and counts_by_year. Args: work_id (W-id, openalex.org URL, bare DOI, or doi.org URL). DOI lookups resolve via the claimant filter; when several works share one DOI the most-cited is selected and doi_claimants + doi_resolution_note are included. Raises not-found for unknown IDs/DOIs.

Field	Type	Requirement and constraints
work_id	string	required

const result = await host.mcp("literature", "openalex_get_work", {"work_id": "W2741809807"})

openalex_citations

List works that CITE a given work (incoming citations) via OpenAlex's citation graph. Args: work_id (W-id/URL/DOI — DOIs cost one extra resolution request), sort (cited_by_count default / publication_date / relevance), max_records (default 50, ceiling 500), include_abstracts. Returns {work_id, api_total (the true citing-work count), n_records_returned, records_truncated, records} (lean work records).

Field	Type	Requirement and constraints
work_id	string	required
sort	string	optional; default: "cited_by_count"; enum: ["cited_by_count", "publication_date", "relevance"]
max_records	integer	optional; default: 50
include_abstracts	boolean	optional; default: false

const result = await host.mcp("literature", "openalex_citations", {"work_id": "W2741809807", "sort": "cited_by_count", "max_records": 50})

openalex_references

List the works a given work CITES (outgoing references), hydrated to full metadata in reference-list order. Args: work_id (W-id/URL/DOI), max_records (default 100, ceiling 500; hydration batched 50/request). Returns {work_id, n_references, n_records_returned, records_truncated, references_not_hydrated (IDs OpenAlex has no record for — never silently dropped), reference_ids (ALL outgoing W-ids), records}.

Field	Type	Requirement and constraints
work_id	string	required
max_records	integer	optional; default: 100

const result = await host.mcp("literature", "openalex_references", {"work_id": "W2741809807", "max_records": 100})

openalex_search_authors

Search OpenAlex author profiles by name. Args: query (matches display name + alternatives; expect homonyms — check affiliations/topics/ORCID), max_records (default 25, ceiling 500). Returns {query, api_total, n_records_returned, records_truncated, records}; each record {author_id, name, orcid, works_count, cited_by_count, h_index, i10_index, affiliations[{institution, years}], last_known_institutions, top_topics}. Use author_id with openalex_get_author.

Field	Type	Requirement and constraints
query	string	required
max_records	integer	optional; default: 25

const result = await host.mcp("literature", "openalex_search_authors", {"query": "Jennifer Doudna", "max_records": 25})

openalex_get_author

Fetch one OpenAlex author profile plus their top-cited works. Args: author_id (A-id, openalex.org URL, or ORCID; CAVEAT: OpenAlex's ORCID pointer can resolve to a sparse duplicate — prefer the A-id from openalex_search_authors), works_sample (default 10, max 200; 0 skips the extra request). Returns the author record plus counts_by_year, top_works_total (true total works count) and top_works (lean work records by citations).

Field	Type	Requirement and constraints
author_id	string	required
works_sample	integer	optional; default: 10

const result = await host.mcp("literature", "openalex_get_author", {"author_id": "A5023888391", "works_sample": 10})

openalex_venue_info

Look up journals/repositories ('sources') in OpenAlex — OA status, DOAJ listing, APC, citation metrics. Args: venue (exact S-id, openalex.org URL, or ISSN for a single record; anything else is a name search), max_records (default 10, ceiling 500; name-search only). Returns: exact -> one source record + counts_by_year; name search -> {query, api_total, n_records_returned, records_truncated, records}. Source record: {source_id, display_name, type, issn_l, issn, host_organization, country_code, homepage_url, is_oa, is_in_doaj, is_core, apc_usd, works_count, cited_by_count, h_index, two_year_mean_citedness, first/last_publication_year, top_topics}.

Field	Type	Requirement and constraints
venue	string	required
max_records	integer	optional; default: 10

const result = await host.mcp("literature", "openalex_venue_info", {"venue": "Nature", "max_records": 10})

arxiv_search

Search arXiv preprints (physics, math, CS, stats, q-bio, ...) via the official Atom API. Args: query (arXiv query string; plain terms search all fields, field prefixes ti:/au:/abs: and booleans AND/OR/ANDNOT work; optional if category or a date range is set), category (arXiv code AND-ed in, e.g. q-bio.GN, cs.LG, stat.ML), date_from / date_to (submission date YYYY-MM-DD, inclusive), start (0-based paging offset; the API paces ~3s between requests — page politely), max_results (default 25, max 100 per call), sort_by (relevance default / submittedDate / lastUpdatedDate), sort_order (descending default / ascending). Returns {search_query (the exact query sent), api_total (arXiv's total match count), start_index, n_records_returned, records_truncated, sort_by, sort_order, records}; each record {arxiv_id, version, id_versioned, title, abstract, authors, published, updated, primary_category, categories, doi, journal_ref, comment, abs_url, pdf_url}. doi/journal_ref appear only after journal publication. Malformed queries raise an error (arXiv's HTTP-200 error feed is detected, never returned as data).

Field	Type	Requirement and constraints
query	string	optional
category	string	optional
date_from	string	optional
date_to	string	optional
start	integer	optional; default: 0
max_results	integer	optional; default: 25
sort_by	string	optional; default: "relevance"; enum: ["relevance", "submittedDate", "lastUpdatedDate"]
sort_order	string	optional; default: "descending"; enum: ["descending", "ascending"]

const result = await host.mcp("literature", "arxiv_search", {"query": "ti:transformer", "category": "cs.LG", "max_results": 10})

arxiv_get_papers

Batch-fetch arXiv paper metadata (incl. abstracts) by ID — one paced request for up to 100 papers. Args: arxiv_ids (up to 100 IDs in any common form — 2103.14030, versioned 2103.14030v2, old-style q-bio/0601001, arXiv:-prefixed, or abs/pdf URLs; unversioned IDs resolve to the latest version). Returns {n_requested, n_found, duplicates (inputs that resolved to an already-returned paper), not_found (unknown AND malformed IDs — arXiv silently skips unknowns and rejects whole batches over malformed ones; this tool does neither), records} — records in requested order, same shape as arxiv_search records. Withdrawn papers still return metadata (check comment for withdrawal notes).

Field	Type	Requirement and constraints
arxiv_ids	array of string	required

const result = await host.mcp("literature", "arxiv_get_papers", {"arxiv_ids": ["2103.14030", "1706.03762v5"]})

crossref_get_work

Retrieve publisher-deposited metadata for a Crossref DOI. A bare DOI, doi: prefix or doi.org URL is accepted. No API key is required. If the DOI belongs to another registration agency, use the matching service; a Crossref 404 does not prove the DOI is invalid. Check the returned DOI, title and source_url.

Field	Type	Requirement and constraints
doi	string	required; minLength: 1; maxLength: 2048

const result = await host.mcp("literature", "crossref_get_work", {"doi": "10.1038/nature12968"})

crossref_get_updates

Read deposited correction, retraction and other update relationships. updated_by points to notices updating this work; update_to points to works updated by this DOI. Preserve relationship direction and source labels. Empty arrays do not establish reliability or prove that no retraction exists.

Field	Type	Requirement and constraints
doi	string	required; minLength: 1; maxLength: 2048

const result = await host.mcp("literature", "crossref_get_updates", {"doi": "10.1038/nature12968"})

datacite_search_records

Search public DataCite dataset/software DOI metadata. Supply query, related_doi or both; query uses DataCite query syntax. Keep the same filters and page_size when following next_page. Page-number retrieval is limited to the first 10,000 records: narrow the query if necessary. Check related_identifiers, rights and landing URLs; metadata does not guarantee downloadable data or reuse permission.

Field	Type	Requirement and constraints
query	string	optional; minLength: 1; maxLength: 2000
related_doi	string	optional; minLength: 1; maxLength: 2048
resource_type	string	optional; default: "dataset"; enum: ["dataset", "software"]
page_size	integer	optional; default: 20; minimum: 1; maximum: 100
page	integer	optional; default: 1; minimum: 1; maximum: 10000

const result = await host.mcp("literature", "datacite_search_records", {"query": "climate", "resource_type": "dataset", "page_size": 5})

datacite_get_record

Retrieve one public DataCite DOI record, including titles, creators, resource type, rights, related identifiers and available version. Accepts a bare DOI, doi: prefix or doi.org URL. Check the identifier and relationship direction before using a linked dataset or software package.

Field	Type	Requirement and constraints
doi	string	required; minLength: 1; maxLength: 2048

const result = await host.mcp("literature", "datacite_get_record", {"doi": "10.14454/qdd3-ps68"})

PubMed

Show operations and parameters

search_articles

Search PubMed (biomedical & life-sciences literature via NCBI esearch) for articles matching a query. Returns the total match count plus a page of PMIDs. Supports PubMed field tags ([Title], [Author], [Journal], [MeSH Terms], ...), Boolean operators, date filtering and sort. PubMed does not index physics / CS / math / pure-chemistry papers.

Field	Type	Requirement and constraints
query	string	required
max_results	integer	optional; default: 20
retstart	integer	optional; default: 0
sort	string	optional; enum: ["relevance", "pub_date", "author", "journal_name", "title"]
date_from	string	optional
date_to	string	optional
datetype	string	optional; default: "pdat"; enum: ["pdat", "edat", "mdat"]

const result = await host.mcp("pubmed", "search_articles", {"query": "CRISPR gene editing", "max_results": 10})

get_article_metadata

Retrieve detailed article metadata from PubMed by PMID (bulk, via efetch): identifiers (pmid/pmc/doi), title, abstract, journal, authors with affiliations, publication date, MeSH terms, article types, language and citation. On every use, cite PubMed and include the returned article DOIs (identifiers.doi) as links.

Field	Type	Requirement and constraints
pmids	['string', 'array']	required

const result = await host.mcp("pubmed", "get_article_metadata", {"pmids": ["35486828", "33264437"]})

find_related_articles

Find related PubMed content for one or more source PMIDs via NCBI elink. pubmed_pubmed (default) returns similar articles ranked by word-weighted similarity of titles/abstracts/MeSH (NOT citations); pubmed_pmc returns full-text PMC links; pubmed_gene/pubmed_protein/pubmed_nucleotide return linked sequence/gene records.

Field	Type	Requirement and constraints
pmids	['string', 'array']	required
link_type	string	optional; default: "pubmed_pubmed"; enum: ["pubmed_pubmed", "pubmed_pmc", "pubmed_nucleotide", "pubmed_protein", "pubmed_gene"]
max_results	integer	optional

const result = await host.mcp("pubmed", "find_related_articles", {"pmids": ["35486828"], "link_type": "pubmed_pubmed"})

lookup_article_by_citation

Resolve bibliographic citations to PMIDs via NCBI ecitmatch. Each citation supplies some of {journal, year, volume, first_page, author, key}; provide 2-3+ fields for reliable matching. Use when you have a reference list and need PMIDs.

Field	Type	Requirement and constraints
citations	array of object	required

const result = await host.mcp("pubmed", "lookup_article_by_citation", {"citations": [{"journal": "Science", "year": 1987, "volume": "235", "first_page": "182", "author": "Palmenberg AC"}]})

convert_article_ids

Convert between PMID, PMCID and DOI via the NCBI/PMC ID Converter. Homogeneous input ids per call (set id_type to match). Commonly used to check whether a PMID has a PMCID (i.e. full text in PMC) before calling get_full_text_article.

Field	Type	Requirement and constraints
ids	['string', 'array']	required
id_type	string	optional; default: "pmid"; enum: ["pmid", "pmcid", "doi"]

const result = await host.mcp("pubmed", "convert_article_ids", {"ids": ["PMC9046468"], "id_type": "pmcid"})

get_full_text_article

Retrieve open-access full text from PubMed Central via Europe PMC by PMC id ("PMC12345" or "12345"). Returns structured section text plus the license; when full text is unavailable the reason is reported explicitly (fulltext_status). Only OA-subset articles have retrievable full text. On every use, cite PubMed and include the returned article DOIs as links.

Field	Type	Requirement and constraints
pmc_ids	['string', 'array']	required

const result = await host.mcp("pubmed", "get_full_text_article", {"pmc_ids": ["PMC9046468"]})

get_copyright_status

Report copyright and license status per PMID by combining PubMed CopyrightInformation, the PMC ID Converter (PMID -> PMCID/DOI), and the PMC <permissions> block (license type, ALI license URL, copyright statement/year). Use to check open-access reuse rights before reproducing content.

Field	Type	Requirement and constraints
pmids	['string', 'array']	required

const result = await host.mcp("pubmed", "get_copyright_status", {"pmids": ["35891187", "34375400"]})

get_pubtator_annotations

Export PubTator 3 BioC JSON entity and relation annotations for published PubMed articles (title/abstract). Keeps passage text, offsets, normalized IDs and relations. Does not submit raw text.

Field	Type	Requirement and constraints
pmids	array	required; minItems: 1; maxItems: 10

const result = await host.mcp("pubmed", "get_pubtator_annotations", {"pmids": ["29355051"]})

search_pubtator

Search one page of PubTator 3 publications by text, entity IDs or relations (e.g. relations:ANY|@CHEMICAL_Doxorubicin|@DISEASE_Neoplasms). Automated relations are research evidence, not clinical conclusions.

Field	Type	Requirement and constraints
query	string	required; minLength: 1; maxLength: 1000
page	integer	optional; default: 1; minimum: 1; maximum: 10000

const result = await host.mcp("pubmed", "search_pubtator", {"query": "relations:ANY|@CHEMICAL_Doxorubicin|@DISEASE_Neoplasms", "page": 1})

Genes & Ontologies

Show operations and parameters

query_genes

Resolve gene identifiers/symbols via mygene.info (batched, up to 1000 terms/request). Use this to map gene symbols to Ensembl gene IDs, Entrez IDs, names, and any other mygene.info field — or the reverse (set scopes to the namespace of your input terms, e.g. "entrezgene", "ensembl.gene", "symbol,alias"). Args: terms (query terms, e.g. ["TP53","BRCA1"]; terms containing commas are not supported); scopes (comma-separated identifier namespaces to match terms against); fields (comma-separated mygene fields to return, or "all"); species (common name "human"/"mouse" or NCBI taxid). Returns {n_input, n_records, not_found, records}. A term matching several genes yields several records (each carries its query). Records are deterministically ordered (input order, then _id).

Field	Type	Requirement and constraints
terms	array of string	required
scopes	string	optional
fields	string	optional; default: "symbol,name,taxid,entrezgene,ensembl.gene"
species	string	optional

const result = await host.mcp("genes", "query_genes", {"terms": ["TP53", "BRCA1"], "scopes": "symbol,alias", "fields": "symbol,name,entrezgene,ensembl.gene", "species": "human"})

list_ontologies

List ontologies in the EBI Ontology Lookup Service (OLS4). With ontology_ids (e.g. ["efo","cl","chebi","go","mondo"]): fetch structured metadata records for just those ontologies; unknown IDs are reported in not_found. Without: the complete OLS4 catalogue (~250 ontologies, paginated fully and count-verified). Returns: {records:[{ontology_id, title, version, status, num_terms, ...}], not_found:[...]} for an ID list, or {records:[...], total_elements, complete} for the full catalogue.

Field	Type	Requirement and constraints
ontology_ids	array of string	optional

const result = await host.mcp("genes", "list_ontologies", {"ontology_ids": ["efo", "go", "mondo"]})

search_ontology_terms

Search ontology terms by label/synonym across one or more OLS4 ontologies. Typical uses: find an EFO ID for a disease name (ontologies=["efo"]), Cell Ontology terms for a cell type (["cl"]), ChEBI terms for a chemical (["chebi"]), GO terms by name (["go"]) — or search all ontologies at once. Args: query (term label, synonym, or identifier); ontologies (lowercase IDs to restrict to; None searches every ontology); exact (whole-string match); include_obsolete (default False); max_results (ranked by OLS relevance). Returns {query, total_found, n_returned, truncated, terms:[{curie, iri, label, short_form, ontology, description, type, is_defining_ontology}]}.

Field	Type	Requirement and constraints
query	string	required
ontologies	array of string	optional
exact	boolean	optional; default: false
include_obsolete	boolean	optional; default: false
max_results	integer	optional; default: 20

const result = await host.mcp("genes", "search_ontology_terms", {"query": "asthma", "ontologies": ["efo"], "max_results": 20})

get_ontology_term

Fetch one ontology term's details, or its complete related-term set. With relation=None: full term record (label, synonyms, description, obsolete flag, direct parents). With a relation: the COMPLETE, fully paginated set of related terms — e.g. relation="hierarchicalChildren" for direct children incl. part_of etc., "descendants"/"hierarchicalDescendants" for the whole subtree, "ancestors"/"hierarchicalAncestors", "parents", "children". Retrieval is count-verified against the API's own total. Args: ontology (lowercase, e.g. "efo","go","cl","chebi"); term_id (CURIE "EFO:0000305"/"GO:0006281" or full IRI); relation (None or one of the listed); include_parents (include direct parent refs when relation is None). Returns: relation=None {curie, iri, label, ontology, short_form, synonyms, description, is_obsolete, has_children, parents}; otherwise {root, relation, total_elements, term_count, terms:[...]}.

Field	Type	Requirement and constraints
ontology	string	required
term_id	string	required
relation	string	optional; enum: ["parents", "children", "ancestors", "descendants", "hierarchicalParents", "hierarchicalChildren", "hierarchicalAncestors", "hierarchicalDescendants"]
include_parents	boolean	optional; default: false

const result = await host.mcp("genes", "get_ontology_term", {"ontology": "go", "term_id": "GO:0006281", "relation": "children"})

get_go_annotations

Retrieve GO annotations for a UniProt gene product from QuickGO (complete, count-verified). Args: uniprot_accession (e.g. "P04637", prefix optional); aspect (omit for all aspects, or one of biological_process/molecular_function/cellular_component); evidence (None/all, a preset "experimental_manual"=manually-assigned experimental evidence, "automatic_iea"=electronic/IEA, or an explicit ECO code like "ECO:0000314"; three-letter GO evidence codes like IDA/IEA are NOT accepted — QuickGO silently ignores goEvidence, filter must use ECO codes); taxon_id (optional NCBI taxon, e.g. 9606); include_term_names (hydrate each record with GO term name/aspect/obsolete via one batched ontology lookup); max_records (cap on records; full set still retrieved and summarized; truncated flags the cap). Returns {gene_product, total_annotations, n_records, complete, truncated, distinct_go_ids (across ALL annotations), records:[{go_id, go_aspect, qualifier, go_evidence, eco_id, reference, assigned_by, date, ...}]}.

Field	Type	Requirement and constraints
uniprot_accession	string	required
aspect	string	optional; enum: ["biological_process", "molecular_function", "cellular_component"]
evidence	string	optional
taxon_id	integer	optional
include_term_names	boolean	optional; default: false
max_records	integer	optional; default: 200

const result = await host.mcp("genes", "get_go_annotations", {"uniprot_accession": "P04637", "aspect": "molecular_function", "evidence": "experimental_manual"})

search_uniprot_entries

Discover active UniProtKB protein entries by exact gene name (including synonyms), protein-name phrase and/or exact organism_id (NCBI taxonomy ID, not descendants). At least one of these filters is required; supplied filters are combined with AND. Optional reviewed=true selects Swiss-Prot, false selects TrEMBL; omitting it includes both. No organism or reviewed default. Text uses UniProt tokenized phrase matching, not arbitrary substring matching or raw query syntax; quotes, backslashes, wildcards and control characters are rejected. Returns one bounded page in accession order, not a complete protein set. For the next page, pass next_cursor as cursor with identical filters and page_size. Cursors are opaque, not offsets or durable snapshots; restart if UniProt rejects a stale cursor.

Supply at least one listed search filter; consult the downloadable schema for complete combination rules.

Field	Type	Requirement and constraints
gene	string	optional; minLength: 1; maxLength: 200; pattern: "^(?=[\\s\\S]*\\S)[^\"\\\\*?\\u0000-\\u001f\\u007f]+$"
protein_name	string	optional; minLength: 1; maxLength: 200; pattern: "^(?=[\\s\\S]*\\S)[^\"\\\\*?\\u0000-\\u001f\\u007f]+$"
organism_id	integer	optional; minimum: 1; maximum: 2147483647
reviewed	boolean	optional
page_size	integer	optional; default: 25; minimum: 1; maximum: 500
cursor	string	optional; minLength: 1; maxLength: 4096; pattern: "^[^\\s\\u0000-\\u001f\\u007f]+$"

const result = await host.mcp("genes", "search_uniprot_entries", {"gene": "TP53", "organism_id": 9606, "reviewed": true, "page_size": 25})

get_uniprot_entries

Fetch UniProtKB records for a list of primary or secondary accessions (batched OR-queries first; unresolved aliases use a direct per-accession fallback). Three modes: fields given → token-lean tabular retrieval of just those UniProt fields (e.g. ["accession","id","protein_name","gene_names","organism_name","length","sequence"]); format is ignored. format="fasta" → per-accession FASTA sequences. format="txt" → per-accession full UniProt flat-file text (complete annotation; can be very large — prefer fields). Args: accessions (e.g. ["P04637","P38398"]); format ("fasta"/"txt", ignored when fields given); fields (optional UniProt REST field names for tabular mode). Returns: fields mode {accessions, fields, n_records, records:[{<column>:value}]}; fasta/txt mode {accessions, format, n_found, missing, records:{accession:text}} — missing lists accessions UniProt returned no record for.

Field	Type	Requirement and constraints
accessions	array of string	required
format	string	optional; enum: ["fasta", "txt"]
fields	array of string	optional

const result = await host.mcp("genes", "get_uniprot_entries", {"accessions": ["P04637", "P38398"], "fields": ["accession", "id", "protein_name", "gene_names", "organism_name", "length"]})

submit_uniprot_id_mapping

Submit up to 100,000 identifiers for UniProt batch ID mapping. from_db/to_db are exact UniProt API database names (e.g. Gene_Name, GeneID, Ensembl, RefSeq_Protein, UniProtKB_AC-ID -> UniProtKB; UniProtKB_AC-ID -> Ensembl or GeneID). Valid pairs are defined by https://rest.uniprot.org/configure/idmapping/fields; unsupported pairs fail upstream. taxon_id is optional only for Gene_Name; specify it to disambiguate species. IDs must be individual strings without whitespace or separators; case and versions are preserved, exact duplicates submitted once. Pass accessions from search_uniprot_entries as ids with from_db=UniProtKB_AC-ID. Sends one POST, never automatically retries or polls. Save job_id, then use get_uniprot_id_mapping_status and get_uniprot_id_mapping_results. UniProt expires results after up to 7 days; cancellation or app shutdown stops local requests, not the remote job. No local job cache or remote cancellation/deletion API is provided. If submission loses its response, a job may exist; do not blindly resubmit.

Field	Type	Requirement and constraints
from_db	string	required; minLength: 1; maxLength: 100; pattern: "^[A-Za-z][A-Za-z0-9_-]*$"
to_db	string	required; minLength: 1; maxLength: 100; pattern: "^[A-Za-z][A-Za-z0-9_-]*$"
ids	array of string	required; minItems: 1; maxItems: 100000
taxon_id	integer	optional; minimum: 1; maximum: 2147483647

const result = await host.mcp("genes", "submit_uniprot_id_mapping", {"from_db":"Gene_Name","to_db":"UniProtKB","ids":["TP53","BRCA1"],"taxon_id":9606})

get_uniprot_id_mapping_status

Check an existing UniProt ID mapping job once. NEW/RUNNING means poll this tool later (at least 3 seconds apart); FINISHED means fetch all pages with get_uniprot_id_mapping_results. Upstream ERROR is normalized to FAILED, a terminal job failure, not unmatched IDs. HTTP 400/500 job failures are read without automatic retries; other HTTP failures (including unknown/expired jobs) propagate. Does not submit a new job or automatically poll.

Field	Type	Requirement and constraints
job_id	string	required; minLength: 1; maxLength: 100; pattern: "^[A-Za-z0-9_-]+$"

const result = await host.mcp("genes", "get_uniprot_id_mapping_status", {"job_id":"ecuuh9h0Md"})

get_uniprot_id_mapping_results

Fetch one page of compact UniProt ID mapping pairs for a finished job. Repeat with next_cursor and identical job_id/page_size until has_more=false; cursors are opaque, not offsets or durable snapshots. Every from/to row is retained, including one-to-many mappings. Merge pairs by from across ALL pages before interpreting multiplicity; a source can span pages. Collect the union of failed_ids reported across pages; never infer unmatched IDs from absence on a page. UniProtKB target IDs can be passed to get_uniprot_entries for annotations or sequences.

Field	Type	Requirement and constraints
job_id	string	required; minLength: 1; maxLength: 100; pattern: "^[A-Za-z0-9_-]+$"
page_size	integer	optional; default: 100; minimum: 1; maximum: 500
cursor	string	optional; minLength: 1; maxLength: 4096; pattern: "^[^\s\u0000-\u001f\u007f]+$"

const result = await host.mcp("genes", "get_uniprot_id_mapping_results", {"job_id":"ecuuh9h0Md","page_size":100})

map_reactome_pathways

Map gene symbols or UniProt accessions to Reactome pathways (AnalysisService token workflow). Args: identifiers (gene symbols if id_type="symbol", UniProt accessions if "uniprot"; no duplicates); id_type ("symbol"/"uniprot"); species (default "Homo sapiens"); resource (AnalysisService molecule-resource view "TOTAL" default; "UNIPROT" restricts to protein-level mappings); include_disease (service default True); compact (True → per-identifier low-level pathways only {stId,name,species} + reactome release version; False → full deterministic result: per-identifier complete pathway sets with entity/reaction statistics (p-values, FDR, found/total) and batch summary incl. identifiers_not_found). Returns: compact {tool, reactome_version, id_type, species, n_input, genes:{identifier:{found, n_lowlevel_pathways, pathways}}}; full adds per-pathway statistics and batch_summary. Maps identifiers to pathways in the requested species, without projecting them to human. Use a supported scientific name, such as Homo sapiens or Mus musculus; the downloadable schema lists all supported names. Empty, unsupported or mismatched species are errors. found and n_found indicate identifier recognition, not pathway membership: a recognized identifier can have zero pathways. Compact mode contains only low-level pathways.

Field	Type	Requirement and constraints
identifiers	array of string	required
id_type	string	required; enum: ["symbol", "uniprot"]
species	string	optional; default: "Homo sapiens"
resource	string	optional; default: "TOTAL"
include_disease	boolean	optional; default: true
compact	boolean	optional; default: true

const result = await host.mcp("genes", "map_reactome_pathways", {"identifiers": ["TP53", "EGFR", "BRCA1"], "id_type": "symbol"})

list_enrichment_sources

List the g:Profiler enrichment sources and their current data versions for one organism. Sources are organism-dependent and include namespaces such as GO:BP, GO:MF, GO:CC, KEGG, Reactome, and WikiPathways when available. g:Profiler stores limited query metadata for service operation; this read-only lookup does not submit a gene list.

Field	Type	Requirement and constraints
organism	string	required; minLength: 1; maxLength: 64; pattern: "^[a-z][a-z0-9_]*$"

const result = await host.mcp("genes", "list_enrichment_sources", {"organism": "hsapiens"})

enrich_gene_set

Run g:Profiler g:GOSt enrichment for a gene set across GO, Reactome, KEGG, WikiPathways, and other organism-supported sources. Supports an explicit organism, custom statistical background, under-representation testing, and g:Profiler multiple-testing correction. Unmapped, ambiguous, and duplicate identifiers are returned in metadata instead of being silently discarded.

Field	Type	Requirement and constraints
genes	array of string	required; minItems: 1; maxItems: 5000
organism	string	required; minLength: 1; maxLength: 64; pattern: "^[a-z][a-z0-9_]*$"
sources	array of string	optional; maxItems: 100
background_genes	array of string	optional; minItems: 1; maxItems: 20000
domain_scope	string	optional; enum: ["annotated", "known", "custom", "custom_annotated"]
correction_method	string	optional; default: "g_SCS"; enum: ["g_SCS", "bonferroni", "fdr"]
user_threshold	number	optional; maximum: 1; exclusiveMinimum: 0
all_results	boolean	optional; default: false
ordered	boolean	optional; default: false
measure_underrepresentation	boolean	optional; default: false
no_iea	boolean	optional; default: false
no_evidences	boolean	optional; default: false
numeric_ns	string	optional; minLength: 1; maxLength: 64

const result = await host.mcp("genes", "enrich_gene_set", {"genes": ["TP53", "EGFR", "BRCA1"], "organism": "hsapiens", "sources": ["GO:BP", "REAC"], "correction_method": "fdr"})

list_enrichr_libraries

List the current Enrichr gene-set libraries and their coverage statistics for one supported Enrichr deployment. The human deployment covers human and mouse libraries; other supported organisms use their dedicated deployments. Use this before enrich_gene_set_enrichr to select libraries for transcription-factor, perturbation, drug, disease, tissue, or cell-type analysis.

Field	Type	Requirement and constraints
organism	string	optional; default: "human"; enum: ["human", "fly", "yeast", "worm", "fish"]

const result = await host.mcp("genes", "list_enrichr_libraries", {"organism": "human"})

enrich_gene_set_enrichr

Run Enrichr enrichment for gene symbols or identifiers accepted by selected Enrichr libraries. This complements g:Profiler with transcription-factor, perturbation, drug, disease, tissue, and cell-type libraries. A custom background uses the Speedrichr API and is currently supported only for the human deployment. Enrichr does not report unmapped identifiers, so mapping_status is always not_reported_by_enrichr. Gene lists are submitted to the external Enrichr service; uploads are temporary external side effects and are not automatically rolled back if a later library request fails.

Field	Type	Requirement and constraints
genes	array of string	required; minItems: 1; maxItems: 5000
libraries	array of string	required; minItems: 1; maxItems: 10
background_genes	array of string	optional; minItems: 1; maxItems: 20000
organism	string	optional; default: "human"; enum: ["human", "fly", "yeast", "worm", "fish"]
description	string	optional; minLength: 1; maxLength: 200
max_results	integer	optional; default: 100; minimum: 1; maximum: 500

const result = await host.mcp("genes", "enrich_gene_set_enrichr", {"genes": ["TP53", "EGFR", "BRCA1"], "libraries": ["ChEA_2022", "LINCS_L1000_Chem_Pert_up"]})

get_hgnc_gene

Fetch human gene nomenclature by exact HGNC symbol. Retains approved/withdrawn status, names, aliases, cross-references and modification dates.

Field	Type	Requirement and constraints
symbol	string	required; minLength: 1; maxLength: 100

const result = await host.mcp("genes", "get_hgnc_gene", {"symbol": "BRCA1"})

resolve_hgnc_alias

Resolve an exact human gene alias symbol through HGNC. Returns every matching gene; never silently chooses among ambiguous aliases. Use get_hgnc_gene for approved symbols.

Field	Type	Requirement and constraints
symbol	string	required; minLength: 1; maxLength: 100

const result = await host.mcp("genes", "resolve_hgnc_alias", {"symbol": "P53"})

get_hgnc_service_info

Read official HGNC REST service metadata, searchable fields and stored fields. Shares request admission with the existing HGNC lookups; no key is required.

No input fields; pass an empty object.

const result = await host.mcp("genes", "get_hgnc_service_info", {})

query_hgnc_field

Fetch or search a documented HGNC field, including historical symbols and external identifiers. Search returns indexed identifiers; fetch returns stored records. Preserve ambiguous matches and approved/withdrawn status instead of silently selecting one gene.

Field	Type	Requirement and constraints
mode	string	optional; default: "fetch"; enum: ["fetch", "search"]
field	string	required; enum: ["symbol", "alias_symbol", "prev_symbol", "name", "hgnc_id", "entrez_id", "ensembl_gene_id"]
value	string	required; minLength: 1; maxLength: 300
max_rows	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("genes", "query_hgnc_field", {"field": "entrez_id", "value": "7157", "mode": "fetch"})

list_hgnc_files

List official HGNC public-bucket objects, sizes, identity/checksum metadata and page token. This only discovers download URLs; it does not download files or create local state. ETag is not a SHA256 checksum.

Field	Type	Requirement and constraints
prefix	string	optional; default: "hgnc/tsv/tsv/"; maxLength: 200; pattern: "^hgnc/[A-Za-z0-9_./-]*$"
cursor	string	optional; default: ""; maxLength: 4096
limit	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("genes", "list_hgnc_files", {"prefix": "hgnc/tsv/tsv/", "limit": 5})

Genomes

Show operations and parameters

blast_submit

Submit one nucleotide or protein sequence to the public NCBI BLAST service for asynchronous similarity search. Set molecule_type explicitly because a protein made only of A/C/G/T is otherwise ambiguous. Returns a RID and the server estimate; call blast_status no more often than once per minute, then blast_results after READY. The sequence is sent to NCBI and is not cached locally; a lost submit response raises blast_submission_unknown and must not be retried automatically. Space all BLAST requests by at least 10 seconds and all requests for the same RID by at least 60 seconds. Keep the RID to resume after restart. NCBI generally retains results for 36 hours; this is not a deletion guarantee. Cancellation, app exit and uninstall stop local requests only; this API has no documented remote cancel/delete operation. No job registry or result cache is added; normal conversation/notebook persistence may retain inputs and outputs.

Field	Type	Requirement and constraints
sequence	string	required; minLength: 1; maxLength: 100000
molecule_type	string	required; enum: ["nucleotide", "protein"]
database	string	optional; enum: ["nt", "core_nt", "refseq_rna", "nr", "refseq_protein", "swissprot"]
evalue	number	optional; exclusiveMinimum: 0; maximum: 1000
hitlist_size	integer	optional; minimum: 1; maximum: 100
megablast	boolean	optional

const result = await host.mcp("genomes", "blast_submit", {"sequence": "ATGCGTACGTAGCTAG", "molecule_type": "nucleotide", "database": "nt"})

blast_status

Check one NCBI BLAST RID once. This is a single SearchInfo request and never polls or waits; respect NCBI guidance to wait at least 60 seconds between checks. Returns WAITING, READY, FAILED, or UNKNOWN (unknown or expired RID). Space all BLAST requests by at least 10 seconds and same-RID requests, including results retrieval, by at least 60 seconds.

Field	Type	Requirement and constraints
rid	string	required; minLength: 1; maxLength: 128

const result = await host.mcp("genomes", "blast_status", {"rid": "AYEFB4DT014"})

blast_results

Fetch bounded results for an NCBI BLAST RID. It makes one request and returns ready=false when the job is still waiting; choose json2, xml2, text, or tabular output after blast_status reports READY. Results are capped at 2 MiB and returned verbatim. tabular means NCBI Text + ALIGNMENT_VIEW=Tabular, which may include HTML comments, PRE tags and report headers; it is not pure TSV or CSV. Wait at least 60 seconds after the last request for this RID, including blast_status. No automatic retries.

Field	Type	Requirement and constraints
rid	string	required; minLength: 1; maxLength: 128
format	string	optional; enum: ["json2", "xml2", "text", "tabular"]

const result = await host.mcp("genomes", "blast_results", {"rid": "AYEFB4DT014", "format": "json2"})

ensembl_lookup

Look up genes, transcripts, or proteins by stable ID, or genes by symbol. query accepts ENS IDs (versioned allowed), FlyBase/WormBase/yeast IDs, or symbols such as BRAF. query_type: auto (default) tries ID first, then symbol only on explicit absence unless the input is a canonical ENS/LRG ID; id uses only ID lookup; symbol uses only symbol lookup without version normalization. species applies only to symbol lookup (default homo_sapiens) and is not inferred. expand includes transcripts, exons and translations (default false). Invalid requests and service failures raise errors.

Field	Type	Requirement and constraints
query	string	required
query_type	string	optional; default: "auto"; enum: ["auto", "id", "symbol"]
species	string	optional; default: "homo_sapiens"
expand	boolean	optional; default: false

const result = await host.mcp("genomes", "ensembl_lookup", {"query": "BRAF", "query_type": "symbol"})

ensembl_xrefs

External cross-references of an Ensembl stable ID — the bridge from Ensembl gene/transcript IDs to HGNC, NCBI (EntrezGene), UniProt, OMIM, RefSeq, Expression Atlas and others. Args: stable_id (ENSG.../ENST..., versioned accepted); external_db (optional exact upstream database-name filter, e.g. HGNC, EntrezGene, Uniprot_gn, MIM_GENE, RefSeq_mRNA; omit for all). Returns {stable_id, external_db, n_xrefs, xrefs} — the COMPLETE list (never truncated), sorted by (dbname, primary_id); each row {dbname, db_display_name, primary_id, display_id, description, synonyms, info_type}. Unknown IDs return n_xrefs:0.

Field	Type	Requirement and constraints
stable_id	string	required
external_db	string	optional

const result = await host.mcp("genomes", "ensembl_xrefs", {"stable_id": "ENSG00000157764", "external_db": "HGNC"})

ensembl_vep_variant

Predict variant consequences with Ensembl VEP — most-severe-first summary of the (often huge) per-transcript consequence list. Without hgvs_notation, variant_id takes precedence and region/allele/allele_orientation are ignored. Otherwise, supply hgvs_notation or both region and allele. HGVS must not be combined with variant_id, region, allele, or allele_orientation. hgvs_notation accepts genomic, coding, or protein HGVS (e.g. ENST00000366667:c.803C>T); reference versions are passed unchanged. HGVS uses the current species assembly from rest.ensembl.org (no assembly selection or liftover); assembly_name reports the resolved assembly. HGVS requests include hgvs=1 and transcript_version=1: transcript_id is versioned, hgvsc/hgvsp are retained when available. Input reference versions are not verified: version_validation is unchecked. Each HGVS result preserves input_reference_annotations from the complete upstream transcript list independently of max_consequences. matched means exact reference identity excluding the version suffix, not validated parsing or a version match; unknown means no comparable annotation (including unmapped gene symbols or genomic references). HGVS alleles retain the upstream strand, including negative strand; no region normalization is applied. allele does not filter results from the ID route. Args: variant_id (dbSNP rsID rs7412, COSMIC COSV..., or HGMD ID); region (1-based inclusive chrom:start-end on the current species assembly, GRCh38 for human, e.g. 7:140753336-140753336; SNV start==end; insertion start=end+1; explicit strand suffix :1/:-1 accepted; coordinates always refer to the reference genome, including on the negative strand); allele (A/C/G/T replacement sequence, or - for deletion; upstream symbolic alleles INS/DUP/DEL/TDUP are accepted in forward orientation); allele_orientation (forward by default, preserving existing calls: allele is on the reference forward strand regardless of the region suffix; region opts into interpreting allele on the region strand, so :-1 reverse-complements sequence alleles before querying; symbolic alleles on a negative region require forward orientation). Every region request is sent on the forward strand; region results are forward-oriented. A negative-strand gene does not require negative-strand input; species (default homo_sapiens); max_consequences (cap on returned per-transcript rows, default 25; full count in n_transcript_consequences, rows kept are most severe HIGH>MODERATE>LOW>MODIFIER; transcript_consequences_truncated flags the cap). Returns {query, n_results, results:[{input, assembly_name, seq_region_name, start, end, strand, allele_string, most_severe_consequence, genes:[{gene_id, gene_symbol, worst_impact, n_transcripts}], n_transcript_consequences, transcript_consequences_truncated, transcript_consequences:[...], n_regulatory_feature_consequences, n_motif_feature_consequences, colocated_variants:[...]}]}. Each transcript consequence retains variant_allele. n_transcripts counts distinct non-empty transcript IDs per gene across the full list; worst_impact spans all returned upstream alleles, while n_transcript_consequences counts rows. HGVS parsing errors retain the upstream reason; unknown rsIDs raise with the upstream message.

Field	Type	Requirement and constraints
variant_id	string	mode-dependent; see exclusion and strand rules above
hgvs_notation	string	mode-dependent; see exclusion and strand rules above; minLength: 1
region	string	mode-dependent; see exclusion and strand rules above
allele	string	mode-dependent; see exclusion and strand rules above
allele_orientation	string	mode-dependent; see exclusion and strand rules above; default: "forward"; enum: ["forward", "region"]
species	string	optional; default: "homo_sapiens"
max_consequences	integer	optional; default: 25

const result = await host.mcp("genomes", "ensembl_vep_variant", {"variant_id": "rs7412", "max_consequences": 25})

ensembl_homology

Orthologues or paralogues of a gene from Ensembl Compara (condensed rows — no alignments/sequences). Args: gene_symbol (resolved to a stable ID in species first; pass exactly one of gene_symbol/gene_id); gene_id (ENSG...); homology_type (orthologues default/paralogues/projections); target_species (restrict to one species); target_taxon (NCBI taxon subtree, e.g. 9443 Primates; combinable with target_species, OR semantics); species (source species, default homo_sapiens); max_homologies (row cap default 200; n_total carries the complete count, homologies_truncated flags the cap). Returns {gene_id, gene_symbol, species, homology_type, target_species, target_taxon, n_total, homologies_truncated, homologies}; rows sorted by (species,id) {type, species, id, protein_id, taxonomy_level, method_link_type}. Quirk: the /homology/symbol route stalls — this tool always resolves symbols itself and queries by stable ID.

Field	Type	Requirement and constraints
gene_symbol	string	optional
gene_id	string	optional
homology_type	string	optional; default: "orthologues"; enum: ["orthologues", "paralogues", "projections"]
target_species	string	optional
target_taxon	integer	optional
species	string	optional; default: "homo_sapiens"
max_homologies	integer	optional; default: 200

const result = await host.mcp("genomes", "ensembl_homology", {"gene_symbol": "BRAF", "target_species": "mus_musculus"})

ensembl_sequence

Fetch sequence from Ensembl — by stable ID (gene/transcript/protein) or by genomic region. Pass EITHER stable_id OR region. Args: stable_id (ENSG.../ENST.../ENSP..., versioned accepted); region (1-based inclusive chrom:start..end or chrom:start-end, GRCh38 for human, max 10Mb); species (for region route, default homo_sapiens; ignored for stable IDs); seq_type (ID route: genomic default/cdna/cds/protein; ignored for regions which always return genomic). This tool returns one sequence: for gene-level cdna/cds/protein requests that resolve to multiple sequences, specify a transcript/protein stable ID instead; max_bytes (payload guard default 400000 — larger sequences have seq omitted; length/sha256/metadata always returned; re-call with larger max_bytes for full text). Returns {found, query, seq_type, id, description, molecule, length, sha256, seq} — length in the unit implied by molecule (bases for dna, residues for protein); seq replaced by seq_omitted when capped; found:false with null fields only when Ensembl explicitly reports the requested stable ID as not found; multiple-sequence requests, incompatible sequence types, and other upstream failures raise errors.

Field	Type	Requirement and constraints
stable_id	string	optional
region	string	optional
species	string	optional; default: "homo_sapiens"
seq_type	string	optional; default: "genomic"; enum: ["genomic", "cdna", "cds", "protein"]
max_bytes	integer	optional; default: 400000

const result = await host.mcp("genomes", "ensembl_sequence", {"stable_id": "ENSP00000288602", "seq_type": "protein"})

ensembl_overlap_region

List Ensembl features overlapping a genomic region — genes, transcripts, regulatory features (enhancers/promoters), repeats, variants, karyotype bands. Args: region (1-based inclusive chrom:start-end GRCh38, e.g. 7:140719327-140925199; upstream rejects spans >5Mb — split larger); feature (gene default/transcript/exon/cds/regulatory/motif/repeat/variation/structural_variation/band/simple/misc); species (default homo_sapiens); max_features (row cap default 500; n_total carries the complete overlap count, features_truncated flags the cap). Returns {region, species, feature, n_total, features_truncated, features} sorted by (start,id). Row shape varies — genes {id, external_name, biotype, description, start, end, strand, canonical_transcript, ...}; regulatory {id, description, start, end, extended_start/end, ...}. Empty regions return n_total:0.

Field	Type	Requirement and constraints
region	string	required
feature	string	optional; default: "gene"; enum: ["gene", "transcript", "exon", "cds", "regulatory", "motif", "repeat", "variation", "structural_variation", "band", "simple", "misc"]
species	string	optional; default: "homo_sapiens"
max_features	integer	optional; default: 500

const result = await host.mcp("genomes", "ensembl_overlap_region", {"region": "7:140719327-140925199", "feature": "gene"})

ncbi_resolve_taxon

Resolve a species or taxon name to NCBI Taxonomy identifiers. Accepts a scientific/common name or numeric TaxID; returns every upstream match so ambiguous names are not silently assigned to the first result.

Field	Type	Requirement and constraints
query	string	required; minLength: 1; maxLength: 200
max_matches	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("genomes", "ncbi_resolve_taxon", {"query": "human"})

ncbi_get_assembly_info

Return the exact NCBI genome assembly identity for a versioned GCF/GCA accession, including taxon, assembly name, UCSC synonym, status, and paired RefSeq/GenBank accession. Versionless accessions are rejected to prevent reproducibility and species-compatibility errors.

Field	Type	Requirement and constraints
assembly_accession	string	required; pattern: "^GC[AF]_[0-9]{9}\\.[0-9]+$"

const result = await host.mcp("genomes", "ncbi_get_assembly_info", {"assembly_accession": "GCF_000001405.40"})

ncbi_get_sequence_aliases

List sequence names and exact UCSC/RefSeq/GenBank aliases for one versioned NCBI assembly. Optionally resolve one sequence name; ambiguous shared chromosome labels are retained as multiple matches instead of choosing an alt or unlocalized scaffold. Results are a bounded prefix controlled by max_sequences (default 200); use a larger cap when the full assembly report is needed.

Field	Type	Requirement and constraints
assembly_accession	string	required; pattern: "^GC[AF]_[0-9]{9}\\.[0-9]+$"
sequence	string	optional; minLength: 1; maxLength: 200
max_sequences	integer	optional; default: 200; minimum: 1; maximum: 5000

const result = await host.mcp("genomes", "ncbi_get_sequence_aliases", {"assembly_accession": "GCF_000001405.40", "sequence": "chr1"})

ucsc_list_tracks

List data tracks available in a UCSC Genome Browser assembly (leaf tracks only — the queryable ones), optionally filtered. Args: genome (hg38 default/hg19/mm39/danRer11/... ~220 assemblies); filter_text (case-insensitive substring over name/short/long label, e.g. phyloP, TFBS, ClinVar; omit to list everything — hg38 has ~24k leaf tracks, you almost always want a filter); max_tracks (row cap default 200; n_total carries the full match count, tracks_truncated flags the cap). Returns {genome, filter_text, n_total, tracks_truncated, tracks} sorted by track name; each row {track, short_label, long_label, type, group, parent}. Use track with ucsc_track_data. Quirk: first call per genome downloads the full ~17MB listing and caches it for the process.

Field	Type	Requirement and constraints
genome	string	optional; default: "hg38"
filter_text	string	optional
max_tracks	integer	optional; default: 200

const result = await host.mcp("genomes", "ucsc_list_tracks", {"genome": "hg38", "filter_text": "phyloP", "max_tracks": 50})

ucsc_track_data

Fetch raw rows of any UCSC Genome Browser track in a region — the generic escape hatch behind ucsc_conservation / ucsc_tfbs_clusters (gene tracks, ClinVar, GWAS catalog, CpG islands, repeats, ...). Args: track (name from ucsc_list_tracks, e.g. knownGene, cpgIslandExt, clinvarMain); chrom (chr-prefixed, chr7/chrX — UCSC requires the prefix); start (0-based half-open; an Ensembl 1-based start is start-1 here); end (exclusive); genome (default hg38); max_rows (API maxItemsOutput, default 1000; truncated reflects the API's own maxItemsLimit flag). Returns {genome, track, chrom, start, end, track_type, items_returned, truncated, rows} — rows in upstream shape (BED-like {chrom, chromStart, chromEnd, name, score, ...}; wiggle {start, end, value}). Unknown tracks raise. Quirk: for some huge tracks the API caps output itself and points at dataDownloadUrl — echoed when present. Coordinates must be non-negative safe integers, with end > start. Invalid values are rejected, not rounded or clamped to another locus.

Field	Type	Requirement and constraints
track	string	required
chrom	string	required
start	integer	required; minimum: 0; maximum: 9007199254740991
end	integer	required; minimum: 0; maximum: 9007199254740991
genome	string	optional; default: "hg38"
max_rows	integer	optional; default: 1000

const result = await host.mcp("genomes", "ucsc_track_data", {"track": "cpgIslandExt", "chrom": "chr7", "start": 140700000, "end": 140800000, "genome": "hg38"})

ucsc_conservation

Evolutionary conservation summary for a region from UCSC phyloP / phastCons tracks (base-wise scores over multi-species alignments). Args: chrom (chr-prefixed); start (0-based half-open); end (exclusive; span capped at 100000 bp — split larger); genome (default hg38); track (optional; defaults: hg19 phyloP100wayAll, hg38 phyloP100way, mm10 phyloP60wayAll, mm39 phyloP35way; other genomes retain the phyloP100way fallback, which may not exist — specify a score track from ucsc_list_tracks when needed; positive=conserved, negative=fast-evolving; alternatives hg38 phastCons100way, phyloP30way, phastCons30way, phyloP447way, phyloP470way; hg19 phastCons100way); include_values (also return per-base {start,end,value} rows capped at max_values, values_truncated flags the cap; default false = summary only); max_values (per-base cap default 2000). Returns {genome, track, chrom, start, end, span_bp, n_bases_covered, coverage_fraction, mean, min, max} (+values, values_truncated when requested). Stats weighted by each row's base span, clipped to window; uncovered bases lower coverage_fraction, not zero-scored. Non-score tracks raise; an upstream-truncated row list also raises.

Field	Type	Requirement and constraints
chrom	string	required
start	integer	required; minimum: 0; maximum: 9007199254740991
end	integer	required; minimum: 0; maximum: 9007199254740991
genome	string	optional; default: "hg38"
track	string	optional
include_values	boolean	optional; default: false
max_values	integer	optional; default: 2000

const result = await host.mcp("genomes", "ucsc_conservation", {"chrom": "chr7", "start": 140753330, "end": 140753380, "track": "phyloP100way"})

ucsc_tfbs_clusters

ENCODE transcription-factor binding site clusters overlapping a region (ChIP-seq peak clusters across hundreds of cell types) — which TFs bind where. Args: chrom (chr-prefixed); start (0-based half-open); end (exclusive); genome (hg38 default track encRegTfbsClustered ENCODE 3, or hg19 wgEncodeRegTfbsClusteredV3; other assemblies raise); max_rows (API maxItemsOutput default 1000; truncated reflects maxItemsLimit). Returns {genome, track, chrom, start, end, items_returned, truncated, n_factors, factors, clusters} — clusters sorted by (chromStart,name) {name (TF symbol e.g. CTCF), chrom, chromStart, chromEnd, score (0-1000), sourceCount (supporting experiments)}; factors is the distinct TF list. Score>=~600 and high sourceCount ~ robust binding. Coordinates must be non-negative safe integers, with end > start. Invalid values are rejected, not rounded or clamped to another locus.

Field	Type	Requirement and constraints
chrom	string	required
start	integer	required; minimum: 0; maximum: 9007199254740991
end	integer	required; minimum: 0; maximum: 9007199254740991
genome	string	optional; default: "hg38"
max_rows	integer	optional; default: 1000

const result = await host.mcp("genomes", "ucsc_tfbs_clusters", {"chrom": "chr7", "start": 140699000, "end": 140760000, "genome": "hg38"})

ucsc_chrom_sizes

Chromosome/contig names and sizes of a UCSC assembly — for validating coordinates and iterating regions. Args: genome (default hg38); filter_text (case-insensitive substring on the name, e.g. chr1; omit for all — hg38 has 711 sequences, mostly alt/random/unplaced; primary chromosomes sort first); max_chroms (row cap default 100; n_total carries the full post-filter count, chroms_truncated flags the cap). Returns {genome, filter_text, chrom_count (assembly-wide from the API), n_total, chroms_truncated, chromosomes:[{name, size_bp}]} sorted by size descending.

Field	Type	Requirement and constraints
genome	string	optional; default: "hg38"
filter_text	string	optional
max_chroms	integer	optional; default: 100

const result = await host.mcp("genomes", "ucsc_chrom_sizes", {"genome": "hg38", "filter_text": "chr1", "max_chroms": 25})

clustalo_submit

Submit three or more protein, DNA or RNA sequences to EMBL-EBI Job Dispatcher Clustal Omega for asynchronous multiple sequence alignment. Input must be uniquely named FASTA records; the service accepts at most 4000 sequences or 4 MiB. Returns a job_id; keep it and call clustalo_status before clustalo_results. The connector requests clustal_num by default, a Clustal alignment with position numbers, suitable for inspecting conserved sites and downstream evolutionary analysis. EMBL-EBI requests a valid contact email. Set a contact email in Settings → Privacy → Share contact email with research data services. A lost submit response may represent an accepted remote job; do not resubmit automatically. EMBL-EBI stores results for a limited provider-controlled period (documented as up to one week); this is not an app-owned deletion guarantee. Keep the job_id to resume after restart. This connector adds no job registry, result cache or automatic resubmission, and cancellation/app exit only stop local requests. The sequence is sent to EMBL-EBI, and the host may retain tool inputs and returned alignment content in conversation or Notebook persistence. Respect EMBL-EBI fair-use guidance: submit no more than 30 jobs in a batch and wait for processing/results before submitting more; this connector does not enforce cross-call throttling. See https://www.ebi.ac.uk/jdispatcher/docs/webservices/ for the official API contract.

Field	Type	Requirement and constraints
sequence	string	required; minLength: 1; maxLength: 4194304
stype	string	required; enum: ["protein", "dna", "rna"]
outfmt	string	optional; enum: ["clustal_num"]
title	string	optional; minLength: 1; maxLength: 200
dealign	boolean	optional
order	string	optional; enum: ["aligned", "input"]

const result = await host.mcp("genomes", "clustalo_submit", {"sequence": ">human\nMKT\n>mouse\nMRT\n>rat\nMRT\n", "stype": "protein"})

clustalo_status

Check one EMBL-EBI Clustal Omega job once. This is a single status request and never polls or waits; call it again after at least 10 seconds until FINISHED, ERROR, FAILURE or NOT_FOUND. Keep the job_id when resuming after a restart.

Field	Type	Requirement and constraints
job_id	string	required; minLength: 1; maxLength: 128

const result = await host.mcp("genomes", "clustalo_status", {"job_id":"clustalo-I20240923-000000-0000-0000000-p1m"})

clustalo_results

Fetch one bounded Clustal Omega clustal_num alignment file for a FINISHED job. Pass the same outfmt returned by clustalo_submit; this tool makes one result request and returns the alignment content plus a filename suggestion. If the provider still reports QUEUED or RUNNING, it returns ready:false with a retry hint; provider failures are errors and retain the job_id for diagnosis. Results are capped at 8 MiB and are returned verbatim so the caller can save the content as an alignment file for conserved-site inspection or downstream phylogenetic analysis. No automatic retries. EMBL-EBI stores results for a limited provider-controlled period (documented as up to one week); this is not an app-owned deletion guarantee. Keep the job_id to resume after restart. This connector adds no job registry, result cache or automatic resubmission, and cancellation/app exit only stop local requests. The sequence is sent to EMBL-EBI, and the host may retain tool inputs and returned alignment content in conversation or Notebook persistence. Respect EMBL-EBI fair-use guidance: submit no more than 30 jobs in a batch and wait for processing/results before submitting more; this connector does not enforce cross-call throttling.

Field	Type	Requirement and constraints
job_id	string	required; minLength: 1; maxLength: 128
outfmt	string	required; enum: ["clustal_num"]

const result = await host.mcp("genomes", "clustalo_results", {"job_id":"clustalo-I20240923-000000-0000-0000000-p1m", "outfmt":"clustal_num"})

ensembl_ld_pairwise

Query linkage disequilibrium (r² and D′) between two variant IDs, such as GWAS Catalog rsIDs, in an explicitly selected population. The caller must supply the full population name in population_name (e.g. 1000GENOMES:phase_3:KHV); this tool does not discover populations or infer ancestry. species defaults to homo_sapiens. Returns upstream variant identities and numeric r2/d_prime without significance or causality inference. High LD does not establish causality. Empty results mean no LD data returned, not zero LD; invalid IDs/populations and service failures remain errors. Reference metadata includes the population, known panel, query URL and retrieval time; assembly/release are null because the LD endpoint does not report them.

Field	Type	Requirement and constraints
variant_id1	string	required; minLength: 1; pattern: "\S"
variant_id2	string	required; minLength: 1; pattern: "\S"
population_name	string	required; minLength: 1; pattern: "\S"
species	string	optional; default: "homo_sapiens"; minLength: 1; pattern: "\S"

const result = await host.mcp("genomes", "ensembl_ld_pairwise", {"variant_id1": "rs6792369", "variant_id2": "rs1042779", "population_name": "1000GENOMES:phase_3:KHV"})

ensembl_ld_proxies

Find nearby variants in LD with a variant ID (e.g. a GWAS rsID) in a required population_name such as 1000GENOMES:phase_3:KHV. species defaults to homo_sapiens. min_r2 defaults to 0.8; min_d_prime defaults to 0; both are inclusive thresholds in [0,1]. window_size is the total width of the centered Ensembl window in kb (integer 1–500, default 500, approximately 250 kb on each side at the default); max_records caps output (integer 1–1000, default 100) and does not limit upstream computation or download size. Results are sorted by r2 descending, then d_prime descending and variant ID, before capping. Coordinates/annotations are upstream attributes. Report the population and reference_data with results. High LD does not establish causality or functional equivalence. Empty results mean no qualifying data returned, not zero LD. Errors remain errors; assembly/release are not reported by this endpoint and remain null. The caller must supply the full population name; this tool does not discover populations or infer ancestry.

Field	Type	Requirement and constraints
variant_id	string	required; minLength: 1; pattern: "\S"
population_name	string	required; minLength: 1; pattern: "\S"
species	string	optional; default: "homo_sapiens"; minLength: 1; pattern: "\S"
min_r2	number	optional; default: 0.8; minimum: 0; maximum: 1
min_d_prime	number	optional; default: 0; minimum: 0; maximum: 1
window_size	integer	optional; default: 500; minimum: 1; maximum: 500
max_records	integer	optional; default: 100; minimum: 1; maximum: 1000

const result = await host.mcp("genomes", "ensembl_ld_proxies", {"variant_id": "rs1042779", "population_name": "1000GENOMES:phase_3:KHV", "min_r2": 0.8, "window_size": 500, "max_records": 100})

Variants

Show operations and parameters

gnomAD coordinate rules: record the dataset pin with the reference assembly. Short-variant gene/region queries use GRCh37 for r2.1/ExAC and GRCh38 for r3/r4; structural-variant gene queries use gnomad_sv_r2_1 (GRCh37) or gnomad_sv_r4 (GRCh38); changing the pin does not convert input coordinates. gene_constraint and the gnomAD ClinVar mirror use a fixed GRCh38 gene lookup and do not accept a dataset argument. Mitochondrial queries also use a fixed GRCh38 parent lookup; supply either a gene or both ordered region bounds, never both modes. Region bounds must be integers from 1 to 999,999,999. The one-million-base difference limit applies to region_variants; it is not a separate mitochondrial limit. Keep release-specific structural-variant IDs with their original SV dataset.

get_variant

Look up one gnomAD short variant by ID and return overall exome/genome frequencies. variant_id is chrom-pos-ref-alt on the dataset's reference build (GRCh38 for r3/r4, GRCh37 for r2.1/ExAC), e.g. 19-44908822-C-T (APOE rs7412); use search_variants to resolve an rsID first. Set include_populations: true when ancestry-specific counts/frequencies are needed for an individual variant. Retain the dataset, allele counts and quality filters when interpreting frequencies; rarity alone does not establish pathogenicity or an ACMG criterion.

Field	Type	Requirement and constraints
variant_id	string	required
dataset	string	optional; default: "gnomad_r4"; enum: ["gnomad_r4", "gnomad_r4_non_ukb", "gnomad_r3", "gnomad_r3_controls_and_biobanks", "gnomad_r3_non_cancer", "gnomad_r3_non_neuro", "gnomad_r3_non_topmed", "gnomad_r3_non_v2", "gnomad_r2_1", "gnomad_r2_1_controls", "gnomad_r2_1_non_cancer", "gnomad_r2_1_non_neuro", "gnomad_r2_1_non_topmed", "exac"]
include_populations	boolean	optional; default: false

const result = await host.mcp("variants", "get_variant", {"variant_id": "19-44908822-C-T", "dataset": "gnomad_r4"})

search_variants

Search gnomAD for variant IDs matching a query string (an rsID like rs7412, a variant ID, or a prefix). Use this to resolve rsIDs to chrom-pos-ref-alt IDs for get_variant.

Field	Type	Requirement and constraints
query	string	required
dataset	string	optional; default: "gnomad_r4"; enum: ["gnomad_r4", "gnomad_r4_non_ukb", "gnomad_r3", "gnomad_r3_controls_and_biobanks", "gnomad_r3_non_cancer", "gnomad_r3_non_neuro", "gnomad_r3_non_topmed", "gnomad_r3_non_v2", "gnomad_r2_1", "gnomad_r2_1_controls", "gnomad_r2_1_non_cancer", "gnomad_r2_1_non_neuro", "gnomad_r2_1_non_topmed", "exac"]

const result = await host.mcp("variants", "search_variants", {"query": "rs7412", "dataset": "gnomad_r4"})

gene_variants

List ALL gnomAD short variants in a gene. Gene bounds and variant coordinates use the dataset reference build (GRCh37 for r2.1/ExAC, GRCh38 for r3/r4). The complete listing can contain thousands of rows for large genes. Pass exactly one of gene_symbol (HGNC symbol, e.g. APOE) or gene_id (Ensembl gene ID, e.g. ENSG00000130203).

Field	Type	Requirement and constraints
gene_symbol	string	optional
gene_id	string	optional
dataset	string	optional; default: "gnomad_r4"; enum: ["gnomad_r4", "gnomad_r4_non_ukb", "gnomad_r3", "gnomad_r3_controls_and_biobanks", "gnomad_r3_non_cancer", "gnomad_r3_non_neuro", "gnomad_r3_non_topmed", "gnomad_r3_non_v2", "gnomad_r2_1", "gnomad_r2_1_controls", "gnomad_r2_1_non_cancer", "gnomad_r2_1_non_neuro", "gnomad_r2_1_non_topmed", "exac"]

const result = await host.mcp("variants", "gene_variants", {"gene_symbol": "APOE", "dataset": "gnomad_r4"})

gene_constraint

gnomAD gene constraint metrics: pLI, observed/expected LoF-missense-synonymous counts with oe ratios + 90% CI bounds, and per-class z-scores. Use to judge a gene's intolerance to loss-of-function (pLI >= 0.9 or oe_lof_upper (LOEUF) < 0.6 ~ LoF-intolerant). Pass exactly one of gene_symbol (e.g. TP53) or gene_id.

Field	Type	Requirement and constraints
gene_symbol	string	optional
gene_id	string	optional

const result = await host.mcp("variants", "gene_constraint", {"gene_symbol": "TP53"})

region_variants

List ALL gnomAD short variants in a genomic region (max 1 Mb — split larger regions into consecutive windows). chrom accepts 1-22, X, Y, an optional chr prefix and lowercase x/y; start/stop are 1-based inclusive and stop - start must be <= 1,000,000. The dataset determines the reference build of the coordinates (GRCh37 for r2.1/ExAC, GRCh38 for r3/r4); input coordinates must already use that build, with no automatic liftover.

Field	Type	Requirement and constraints
chrom	string	required
start	integer	required; minimum: 1; maximum: 999999999
stop	integer	required; minimum: 1; maximum: 999999999
dataset	string	optional; default: "gnomad_r4"; enum: ["gnomad_r4", "gnomad_r4_non_ukb", "gnomad_r3", "gnomad_r3_controls_and_biobanks", "gnomad_r3_non_cancer", "gnomad_r3_non_neuro", "gnomad_r3_non_topmed", "gnomad_r3_non_v2", "gnomad_r2_1", "gnomad_r2_1_controls", "gnomad_r2_1_non_cancer", "gnomad_r2_1_non_neuro", "gnomad_r2_1_non_topmed", "exac"]

const result = await host.mcp("variants", "region_variants", {"chrom": "1", "start": 55039475, "stop": 55064852, "dataset": "gnomad_r4"})

liftover_variant

Map a variant ID between reference builds (GRCh37 <-> GRCh38) using gnomAD's liftover table. variant_id is chrom-pos-ref-alt on source_build. The route is directional: a GRCh38 ID passed with source_build=GRCh37 returns zero results, not an error.

Field	Type	Requirement and constraints
variant_id	string	required
source_build	string	optional; default: "GRCh37"; enum: ["GRCh37", "GRCh38"]

const result = await host.mcp("variants", "liftover_variant", {"variant_id": "1-55516888-G-GA", "source_build": "GRCh37"})

clinvar_variants

List ClinVar variants in a gene as mirrored by gnomAD, with clinical significance, review status and gold stars. The output pins gnomAD's ClinVar snapshot via clinvar_release_date. Pass exactly one of gene_symbol (e.g. BRCA1) or gene_id.

Field	Type	Requirement and constraints
gene_symbol	string	optional
gene_id	string	optional

const result = await host.mcp("variants", "clinvar_variants", {"gene_symbol": "BRCA1"})

structural_variants

List gnomAD structural variants (deletions, duplications, insertions, inversions, CNVs...) overlapping a gene. Pass exactly one of gene_symbol (e.g. TP53) or gene_id. dataset is an SV pin — gnomad_sv_r4 (default, GRCh38) or gnomad_sv_r2_1 (GRCh37); SV IDs are release-specific.

Field	Type	Requirement and constraints
gene_symbol	string	optional
gene_id	string	optional
dataset	string	optional; default: "gnomad_sv_r4"; enum: ["gnomad_sv_r4", "gnomad_sv_r2_1"]

const result = await host.mcp("variants", "structural_variants", {"gene_symbol": "TP53", "dataset": "gnomad_sv_r4"})

get_structural_variant

Look up one gnomAD structural variant by its release-specific SV ID (e.g. DEL_CHR17_599B1512 in gnomad_sv_r4). IDs do NOT carry across releases — dataset (gnomad_sv_r4 default, or gnomad_sv_r2_1) must match the release the ID came from.

Field	Type	Requirement and constraints
sv_id	string	required
dataset	string	optional; default: "gnomad_sv_r4"; enum: ["gnomad_sv_r4", "gnomad_sv_r2_1"]

const result = await host.mcp("variants", "get_structural_variant", {"sv_id": "DEL_CHR17_A5250EA9", "dataset": "gnomad_sv_r4"})

mitochondrial_variants

List gnomAD mitochondrial variants with heteroplasmy-aware counts (ac_het, ac_hom, max_heteroplasmy) for a mitochondrial gene OR a chrM coordinate window. The mitochondrial callset is available only through the GRCh38 gnomAD r3/r4 dataset pins: use dataset gnomad_r3 or gnomad_r4. Pass a gene (gene_symbol like MT-TL1, or gene_id) OR a region (region_start + region_stop), not both.

Field	Type	Requirement and constraints
gene_symbol	string	optional
gene_id	string	optional
region_start	integer	optional; minimum: 1; maximum: 999999999
region_stop	integer	optional; minimum: 1; maximum: 999999999
dataset	string	optional; default: "gnomad_r4"; enum: ["gnomad_r4", "gnomad_r3"]

const result = await host.mcp("variants", "mitochondrial_variants", {"gene_symbol": "MT-TL1", "dataset": "gnomad_r4"})

clinvar_search

Search ClinVar directly (live NCBI, not gnomAD's snapshot) and return matching variation records with clinical significance, review status and gold stars. Requires a contact email (Settings → Credentials → Literature access → Contact email) per NCBI E-utilities usage policy. Args: query (a ClinVar Entrez query — free text like "TP53 R175H" or an HGVS string works, and fielded terms compose with AND/OR/NOT, e.g. BRCA1[gene], pathogenic[CLIN_SIG], "Lynch syndrome"[dis], single_nucleotide_variant[Type of variation]; an rsID also works but clinvar_variant_by_rsid returns fuller records), max_records (page cap 1-200, default 50). The match TOTAL is always reported; when total > max_records the list is a capped prefix (ClinVar relevance/recency order) and truncated is true. NCBI E-utilities intermittently return HTTP 500 under load — retry once a few seconds later if that surfaces.

Field	Type	Requirement and constraints
query	string	required
max_records	integer	optional; default: 50

const result = await host.mcp("variants", "clinvar_search", {"query": "BRCA1 pathogenic[CLIN_SIG]", "max_records": 50})

clinvar_get_records

Fetch full ClinVar records for a batch of VCV/RCV accessions or bare variation IDs. Requires a contact email (Settings → Credentials → Literature access → Contact email) per NCBI E-utilities usage policy. Args: accessions (up to 50 identifiers, mixed forms accepted — VCV000045122 (versioned VCV000045122.3 ok; resolved locally, free), RCV000019428 (each RCV costs one extra esearch), or a bare ClinVar variation ID (45122). rsIDs are rejected — use clinvar_variant_by_rsid. An RCV (one variant-condition pair) resolves to its parent VCV variation record). Never silently drops an input.

Field	Type	Requirement and constraints
accessions	['string', 'array']	required

const result = await host.mcp("variants", "clinvar_get_records", {"accessions": ["VCV000045122", "RCV000019428", "45123"]})

clinvar_variant_by_rsid

All ClinVar variation records that reference a dbSNP rsID, with full classifications (an rsID can map to several VCVs — one per alternate allele, e.g. rs121913529 covers KRAS G12D/G12V/G12A). Requires a contact email (Settings → Credentials → Literature access → Contact email) per NCBI E-utilities usage policy. Args: rsid (dbSNP reference SNP ID, e.g. rs7412; case-insensitive, must match rs<digits>), max_records (cap 1-200, default 50). total always carries the true match count and truncated flags a capped listing; total == 0 means ClinVar has no record for the rsID.

Field	Type	Requirement and constraints
rsid	string	required
max_records	integer	optional; default: 50

const result = await host.mcp("variants", "clinvar_variant_by_rsid", {"rsid": "rs121913529", "max_records": 50})

dbsnp_get_rsids

Canonical dbSNP RefSNP records for a batch of rsIDs: GRCh38+GRCh37 placements, alleles, gene context, per-study allele frequencies, and ClinVar cross-references. Requires a contact email (Settings → Credentials → Literature access → Contact email) per NCBI E-utilities usage policy; without one the tool returns {error: 'contact_email_required', message}. Args: rsids (up to 20 rs<digits>, case-insensitive) — each costs one paced NCBI Variation Services request, so large batches take ~1 s per rsID. Returns {n_requested, records, not_found (rs numbers dbSNP doesn't know), not_processed (rsIDs skipped when the wall-clock budget ran out — re-request just those)}. Each record: {rsid, status, create_date, last_update_date, last_update_build_id, n_citations, citations_pmids (capped at 20; citations_truncated flags the cap), variant_type, mane_select_ids, placements, alleles}. status is 'live', 'merged' (record instead carries merged_into — re-query those rsIDs) or 'no_data' (withdrawn/unsupported). placements give 1-based chromosome coordinates with ref/alts per assembly (GRCh38 first, is_primary true). Each alt-allele entry: {allele, ref, spdi (0-based interbase), hgvs, frequencies: [{study, study_version, allele_count, total_count, af}] (ALFA, 1000Genomes, TOPMED, gnomAD...), clinvar: [{rcv_accession, clinical_significances, review_status, last_evaluated_date, disease_names}], genes: [{symbol, gene_id, name, orientation, consequences (SO terms), mane_select: [{transcript_hgvs, protein_spdi}]}]}.

Field	Type	Requirement and constraints
rsids	array of string	required

const result = await host.mcp("variants", "dbsnp_get_rsids", {"rsids": ["rs7412", "rs429358"]})

dbsnp_search_by_region

List dbSNP rsIDs in a genomic window (esearch db=snp positional index — NCBI Variation Services has no region endpoint). Requires a contact email (Settings → Credentials → Literature access → Contact email) per NCBI E-utilities usage policy; without one the tool returns {error: 'contact_email_required', message}. Args: chrom (1-22, X, Y or MT; 'chr' prefix tolerated), start (1-based inclusive), stop (inclusive; span capped at 1 Mb — split larger regions into consecutive windows; dense regions hold many thousands of rsIDs per kb, so keep windows small or raise max_rsids), assembly (which positional index — 'GRCh38' default -> [CPOS], or 'GRCh37' -> [CPOS_GRCH37]; coordinates must be on the chosen assembly), max_rsids (listing cap 1-1000, default 200). Returns {chrom, start, stop, assembly, term (the exact Entrez query used), total (the API's own count), n_returned, truncated, rsids}. truncated is true when total > n_returned — the list is then a prefix in Entrez default order (descending rs number), never a silent truncation. Feed rsIDs (<= 20 at a time) to dbsnp_get_rsids for full records.

Field	Type	Requirement and constraints
chrom	string	required
start	integer	required
stop	integer	required
assembly	string	optional; default: "GRCh38"; enum: ["GRCh38", "GRCh37"]
max_rsids	integer	optional; default: 200

const result = await host.mcp("variants", "dbsnp_search_by_region", {"chrom": "19", "start": 44905000, "stop": 44910000, "assembly": "GRCh38"})

mavedb_search_score_sets

Search public MaveDB multiplexed assays of variant effect (MAVE) score sets by text, such as a gene symbol, protein or assay. No API key or contact email is required. Returns one page with the upstream total when known; functional scores are assay-specific and are not clinical classifications or population frequencies.

Field	Type	Requirement and constraints
text	string	required; minLength: 1; maxLength: 1000; pattern: "\S"
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000000
limit	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("variants", "mavedb_search_score_sets", {"text":"BRCA1","limit":20})

mavedb_get_score_set

Retrieve a published MaveDB score set by URN, including targets, assay metadata, license, publications and experiment relationships. Includes official full CSV and mapped-variant download URLs for manual download by the user; do not fetch these URLs with raw HTTP to bypass host.mcp. Read the assay methods and score calibration before interpreting functional effects.

Field	Type	Requirement and constraints
urn	string	required; pattern: "^urn:mavedb:[0-9]{8}-(?:[a-z]+|0)-[1-9][0-9]*$"

const result = await host.mcp("variants", "mavedb_get_score_set", {"urn":"urn:mavedb:00000003-a-1"})

mavedb_download_scores

Download a CSV page of MaveDB variant scores (default 1000 rows, maximum 10000). Uses start/limit, not offset. Returns original CSV text, including all score columns and NA values, for saving with Notebook file APIs; this tool does not write a local file. Also returns the unpaginated official download URL for manual download by the user; do not fetch these URLs with raw HTTP to bypass host.mcp. Use numVariants from mavedb_get_score_set to plan pages; a page is not the full dataset.

Field	Type	Requirement and constraints
urn	string	required; pattern: "^urn:mavedb:[0-9]{8}-(?:[a-z]+|0)-[1-9][0-9]*$"
start	integer	optional; default: 0; minimum: 0; maximum: 1000000000
limit	integer	optional; default: 1000; minimum: 1; maximum: 10000

const result = await host.mcp("variants", "mavedb_download_scores", {"urn":"urn:mavedb:00000003-a-1","start":0,"limit":1000})

mavedb_get_mapped_variants

Retrieve existing MaveDB variant mappings for a published score set, including GA4GH VRS preMapped/postMapped objects, reference sequence identifiers, VRS version and mapping errors. This reads mappings already computed by MaveDB; it does not submit variants or perform liftover. The upstream endpoint is unpaginated and the shared 64 MiB response limit applies. For larger datasets, offer the official URL from mavedb_get_score_set for manual download by the user; do not fetch these URLs with raw HTTP to bypass host.mcp. HTTP 404 can mean no mapping records exist, not only that the score set URN is unavailable. Returned records may include failed mappings.

Field	Type	Requirement and constraints
urn	string	required; pattern: "^urn:mavedb:[0-9]{8}-(?:[a-z]+|0)-[1-9][0-9]*$"

const result = await host.mcp("variants", "mavedb_get_mapped_variants", {"urn":"urn:mavedb:00000003-a-1"})

mavedb_get_experiment

Retrieve a public MaveDB experiment by experiment URN (without the score set suffix), including methods, publications, experiment set and scoreSetUrns. Supports the special -0 meta-analysis experiment as well as letter-indexed experiments. No authentication is required.

Field	Type	Requirement and constraints
urn	string	required; pattern: "^urn:mavedb:[0-9]{8}-(?:[a-z]+|0)$"

const result = await host.mcp("variants", "mavedb_get_experiment", {"urn":"urn:mavedb:00000003-a"})

mavedb_get_experiment_score_sets

List the score sets visible to a public reader of a MaveDB experiment. The upstream endpoint filters by visibility and supersession chains, so this is not a complete version history. It returns the selected list without pagination. HTTP 404 can mean no associated score sets are available, not only that the experiment URN is unavailable. Use the returned score set URNs to retrieve functional scores or mappings.

Field	Type	Requirement and constraints
urn	string	required; pattern: "^urn:mavedb:[0-9]{8}-(?:[a-z]+|0)$"

const result = await host.mcp("variants", "mavedb_get_experiment_score_sets", {"urn":"urn:mavedb:00000003-a"})

clinvar_get_submissions

Fetch individual SCV submission evidence from official ClinVar VCV XML. Requires the same contact email as clinvar_search. Pass accession: a VCV accession (optional .version is honored) or a positive variation ID. Unversioned input retrieves the latest VCV. RCV, SCV and rsIDs are not accepted. Returns submitted classifications separately for germline, somatic clinical impact and oncogenicity, conditions, submitter, evaluation date, assertion methods, public classification comments, observed evidence and citations where provided. Missing source fields stay null/empty. Compare submissions within the same classification type and condition; this tool does not infer conflicts. max_submissions sets page size (1-200, default 200); offset defaults to 0. For later pages, pass the returned next_page arguments, which pin the VCV version; offset > 0 requires a versioned VCV. Each page re-fetches the complete XML; there is no result cache. Included records contain indirect references rather than direct SCV evidence. Duplicate SCVs retain the highest version present in the requested snapshot.

Field	Type	Requirement and constraints
accession	string	required
max_submissions	integer	optional; default: 200; minimum: 1; maximum: 200
offset	integer	optional; default: 0; minimum: 0

const result = await host.mcp("variants", "clinvar_get_submissions", {"accession":"VCV000045122"})

Clinical Trials

Show operations and parameters

search_trials

PRIMARY search over ClinicalTrials.gov. Filter by condition, intervention, sponsor, location, status (e.g. ["RECRUITING"]), phase (["PHASE1".."PHASE4"]) and study_type. condition/intervention/sponsor/location accept Essie query syntax (boolean AND/OR/NOT, "quoted phrases", grouping, automatic synonyms). Page with page_token; set count_total for the total match count. advanced_query merges a raw Essie expression into filter.advanced.

Field	Type	Requirement and constraints
condition	string	optional
intervention	string	optional
sponsor	string	optional
location	string	optional
status	array of string	optional
phase	array of string	optional
study_type	string	optional; enum: ["INTERVENTIONAL", "OBSERVATIONAL", "EXPANDED_ACCESS"]
advanced_query	string	optional
page_size	integer	optional; default: 10; minimum: 1; maximum: 1000
page_token	string	optional
count_total	boolean	optional; default: false

const result = await host.mcp("clinical-trials", "search_trials", {"condition": "lung cancer", "status": ["RECRUITING"], "phase": ["PHASE3"], "count_total": true, "page_size": 10})

get_trial_details

Get comprehensive details for one trial by NCT id (format "NCT" + 8 digits; a bare number is prefixed, case-insensitive). Returns full eligibility criteria, study design, primary/secondary/other endpoints, all locations, sponsor and collaborators, dates, enrollment, and a results link.

Field	Type	Requirement and constraints
nct_id	string	required

const result = await host.mcp("clinical-trials", "get_trial_details", {"nct_id": "NCT03661411"})

search_by_sponsor

Find trials sponsored by a company or organization (partial name match, e.g. "Pfizer" matches "Pfizer Inc"). Optionally narrow by condition, phase and status. Set count_total for the total number of trials by the sponsor. Page with page_token.

Field	Type	Requirement and constraints
sponsor_name	string	required
condition	string	optional
phase	array of string	optional
status	array of string	optional
page_size	integer	optional; default: 10; minimum: 1; maximum: 1000
page_token	string	optional
count_total	boolean	optional; default: false

const result = await host.mcp("clinical-trials", "search_by_sponsor", {"sponsor_name": "Pfizer", "phase": ["PHASE3"], "count_total": true})

search_investigators

Find principal investigators and research sites by condition, institution, location or investigator_name. institution filters on the site facility and takes precedence over location; investigator_name searches OverallOfficialName and ResponsiblePartyInvestigatorFullName. Returns site contacts (names, roles, affiliations, facilities, cities) with their trial NCT ids. page_size caps how many trials are scanned.

Field	Type	Requirement and constraints
condition	string	optional
institution	string	optional
location	string	optional
investigator_name	string	optional
status	array of string	optional
page_size	integer	optional; default: 20; minimum: 1; maximum: 1000

const result = await host.mcp("clinical-trials", "search_investigators", {"condition": "Alzheimer", "institution": "Mayo Clinic", "page_size": 20})

analyze_endpoints

Analyze primary/secondary/other outcome measures (endpoints). Provide ONLY nct_id (single-trial mode) OR condition (aggregate mode across trials); if both are given, nct_id takes precedence. Aggregate mode may be narrowed by phase and start_date_after (YYYY-MM-DD) and scans up to page_size trials. Returns the endpoint lists plus the most common measure names across the analyzed trials.

Field	Type	Requirement and constraints
nct_id	string	optional
condition	string	optional
phase	array of string	optional
start_date_after	string	optional
page_size	integer	optional; default: 50; minimum: 1; maximum: 1000

const result = await host.mcp("clinical-trials", "analyze_endpoints", {"nct_id": "NCT03661411"})

search_by_eligibility

Patient-trial matching. DEFAULTS to RECRUITING trials unless status is set. Supply either min_age or max_age for one patient age ("65 Years", "6 Months"); both trial age bounds are checked. If both are supplied, the trial must admit the entire patient age interval. Missing trial age bounds are unrestricted. sex MALE/FEMALE includes all-comer trials; ALL or omitted sex applies no sex filter. eligibility_keywords searches the inclusion/exclusion criteria text (e.g. "HbA1c > 8", "BRCA mutation", "ECOG 0-1"). At least one of condition, eligibility_keywords, min_age, max_age or sex is required. Page with page_token.

Field	Type	Requirement and constraints
condition	string	optional
eligibility_keywords	string	optional
min_age	string	optional
max_age	string	optional
sex	string	optional; enum: ["ALL", "MALE", "FEMALE"]
status	array of string	optional
page_size	integer	optional; default: 10; minimum: 1; maximum: 1000
page_token	string	optional

const result = await host.mcp("clinical-trials", "search_by_eligibility", {"condition": "diabetes", "min_age": "65 Years", "sex": "FEMALE"})

get_trial_results

Read posted trial results by NCT id (case-insensitive; bare 8 digits accepted). Returns actual outcome measurements, group-specific counts and denominators, units, statistical analyses, participant flow, baseline characteristics, adverse events and reporting caveats from resultsSection. Nested fields retain the official API camelCase names and hierarchy. Resolve groupId/groupIds only against the groups in the same module or outcome; do not join them to protocol arms or other modules. Missing data does not mean zero events or no treatment effect.

Field	Type	Requirement and constraints
nct_id	string	required

const result = await host.mcp("clinical-trials", "get_trial_results", {"nct_id": "NCT04280705"})

Clinical Genomics

Show operations and parameters

clingen_gene_validity

ClinGen gene-disease validity curations (how strong the evidence is that variation in a gene causes a disease: Definitive/Strong/Moderate/Limited/Disputed/Refuted/No Known Disease Relationship). Omit gene to list all 3,600+ curations.

Field	Type	Requirement and constraints
gene	string	optional

const result = await host.mcp("clinical-genomics", "clingen_gene_validity", {"gene": "BRCA2"})

clingen_dosage_sensitivity

ClinGen dosage sensitivity curations: haploinsufficiency and triplosensitivity assertions for genes (and optionally ISCA genomic/CNV regions). A gene symbol or an ISCA region id filters exactly; omit for the full table.

Field	Type	Requirement and constraints
gene	string	optional
include_regions	boolean	optional; default: false

const result = await host.mcp("clinical-genomics", "clingen_dosage_sensitivity", {"gene": "TP53"})

clingen_actionability

ClinGen clinical actionability curations: for disorders associated with a gene, whether early intervention in pre-symptomatic carriers is actionable (intervention/outcome pairs with severity, likelihood, effectiveness, nature-of-intervention component scores and the total score). Gene filter matches any member of multi-gene topics.

Field	Type	Requirement and constraints
gene	string	optional
context	string	optional; default: "both"; enum: ["adult", "pediatric", "both"]

const result = await host.mcp("clinical-genomics", "clingen_actionability", {"gene": "BRCA1", "context": "adult"})

clingen_variant_classifications

ClinGen Evidence Repository (ERepo) expert-panel variant pathogenicity classifications (VCEP interpretations under ACMG criteria). Provide EXACTLY ONE of gene (HGNC symbol), caid (ClinGen canonical allele id, e.g. CA114360), or hgvs (e.g. NM_000277.2:c.1222C>T). Complete retrieval (matchLimit=none).

Field	Type	Requirement and constraints
gene	string	optional
caid	string	optional
hgvs	string	optional

const result = await host.mcp("clinical-genomics", "clingen_variant_classifications", {"gene": "BRCA1"})

civic_search_genes

Find CIViC gene records by exact Entrez symbol (e.g. "BRAF"). Fully paginated, count-verified. Use the returned CIViC gene id with civic_gene_variants.

Field	Type	Requirement and constraints
entrez_symbol	string	required

const result = await host.mcp("clinical-genomics", "civic_search_genes", {"entrez_symbol": "BRAF"})

civic_gene_variants

All variants of one CIViC gene (by CIViC gene id), fully paginated — complete even for genes with hundreds of variants. Sorted by variant id.

Field	Type	Requirement and constraints
gene_id	integer	required

const result = await host.mcp("clinical-genomics", "civic_gene_variants", {"gene_id": 5})

civic_get_variant

One CIViC variant by its CIViC variant id (aliases, variant types, feature/gene linkage, coordinates for gene variants). Returns found=false if absent.

Field	Type	Requirement and constraints
variant_id	integer	required

const result = await host.mcp("clinical-genomics", "civic_get_variant", {"variant_id": 12})

civic_search_variants

Search CIViC variants by name substring (e.g. "V600"), optionally scoped to a CIViC gene id. Fully paginated; sorted by variant id.

Field	Type	Requirement and constraints
name	string	required
gene_id	integer	optional

const result = await host.mcp("clinical-genomics", "civic_search_variants", {"name": "V600", "gene_id": 5})

civic_get_evidence_item

One CIViC evidence item by id: clinical significance of a molecular profile in a disease/therapy context (evidence level A-E, type, direction, significance, rating, disease, therapies, source). Returns found=false if absent.

Field	Type	Requirement and constraints
evidence_id	integer	required

const result = await host.mcp("clinical-genomics", "civic_get_evidence_item", {"evidence_id": 1409})

civic_search_evidence

Search CIViC evidence items by any combination of filters; fully paginated, count-verified, sorted by ascending evidence id. Enum filters take CIViC GraphQL enum values verbatim (evidence_level "A".."E"; evidence_type PREDICTIVE|PROGNOSTIC|DIAGNOSTIC|PREDISPOSING|ONCOGENIC|FUNCTIONAL; evidence_direction SUPPORTS|DOES_NOT_SUPPORT; status ACCEPTED|SUBMITTED|REJECTED|ALL). Provide at least one filter — no filters walks the entire 10k+ corpus.

Field	Type	Requirement and constraints
disease_name	string	optional
therapy_name	string	optional
evidence_level	string	optional
evidence_type	string	optional
evidence_direction	string	optional
significance	string	optional
variant_origin	string	optional
evidence_rating	integer	optional
status	string	optional
molecular_profile_name	string	optional
molecular_profile_id	integer	optional
variant_id	integer	optional
disease_id	integer	optional
therapy_id	integer	optional
phenotype_id	integer	optional
source_id	integer	optional
assertion_id	integer	optional

const result = await host.mcp("clinical-genomics", "civic_search_evidence", {"disease_name": "melanoma", "evidence_level": "A"})

civic_get_assertion

One CIViC assertion by id: an expert-curated summary claim (AMP/ASCO/CAP tier, ACMG/ClinGen codes, FDA companion-test flags) aggregating evidence for a molecular profile in a disease/therapy context. Returns found=false if absent.

Field	Type	Requirement and constraints
assertion_id	integer	required

const result = await host.mcp("clinical-genomics", "civic_get_assertion", {"assertion_id": 7})

civic_search_assertions

Search CIViC assertions by any combination of filters; fully paginated, count-verified, sorted by ascending assertion id. assertion_type PREDICTIVE|PROGNOSTIC|DIAGNOSTIC|PREDISPOSING|ONCOGENIC; assertion_direction SUPPORTS|DOES_NOT_SUPPORT; amp_level e.g. TIER_I_LEVEL_A; status ACCEPTED|SUBMITTED|REJECTED|ALL. No filters walks the full corpus.

Field	Type	Requirement and constraints
disease_name	string	optional
therapy_name	string	optional
assertion_type	string	optional
assertion_direction	string	optional
significance	string	optional
amp_level	string	optional
status	string	optional
molecular_profile_name	string	optional
molecular_profile_id	integer	optional
variant_id	integer	optional
variant_name	string	optional
disease_id	integer	optional
therapy_id	integer	optional
phenotype_id	integer	optional
evidence_id	integer	optional
summary	string	optional

const result = await host.mcp("clinical-genomics", "civic_search_assertions", {"disease_name": "melanoma"})

civic_get_molecular_profile

One CIViC molecular profile by id (variant combination that evidence/assertions attach to), incl. parsed name, score, and component variants. Returns found=false if absent.

Field	Type	Requirement and constraints
mp_id	integer	required

const result = await host.mcp("clinical-genomics", "civic_get_molecular_profile", {"mp_id": 12})

civic_search_molecular_profiles

Search CIViC molecular profiles by name substring (e.g. "BRAF V600E"). Fully paginated; sorted by id.

Field	Type	Requirement and constraints
name	string	required

const result = await host.mcp("clinical-genomics", "civic_search_molecular_profiles", {"name": "BRAF V600E"})

civic_search_diseases

Search CIViC disease records by name substring (e.g. "melanoma"). Returns DOIDs + display names; fully paginated; sorted by id.

Field	Type	Requirement and constraints
name	string	required

const result = await host.mcp("clinical-genomics", "civic_search_diseases", {"name": "melanoma"})

civic_search_therapies

Search CIViC therapy records by name substring (e.g. "vemurafenib"). Returns NCIt ids + names; fully paginated; sorted by id.

Field	Type	Requirement and constraints
name	string	required

const result = await host.mcp("clinical-genomics", "civic_search_therapies", {"name": "vemurafenib"})

open_targets_graphql

Run an arbitrary GraphQL query against the Open Targets Platform API (targets, diseases, drugs, target-disease association scores, evidence, tractability, safety, known drugs). Introspection queries work for schema discovery. Note knownDrugs was renamed to drugAndClinicalCandidates upstream.

Field	Type	Requirement and constraints
query	string	required
variables	object	optional

const result = await host.mcp("clinical-genomics", "open_targets_graphql", {"query": "query($id: String!){ target(ensemblId: $id){ approvedSymbol associatedDiseases{ count } } }", "variables": {"id": "ENSG00000157764"}})

open_targets_disease_drugs

Known/investigational drugs for a disease (Open Targets Platform) — wraps Disease.drugAndClinicalCandidates. efo_id is a disease ontology id (EFO/MONDO/etc., e.g. "MONDO_0004992").

Field	Type	Requirement and constraints
efo_id	string	required
size	integer	optional; default: 25

const result = await host.mcp("clinical-genomics", "open_targets_disease_drugs", {"efo_id": "MONDO_0004992", "size": 25})

open_targets_disease_targets

Top associated targets for a disease, ranked by Open Targets overall association score — wraps Disease.associatedTargets. efo_id is a disease ontology id (EFO/MONDO/etc.).

Field	Type	Requirement and constraints
efo_id	string	required
size	integer	optional; default: 25

const result = await host.mcp("clinical-genomics", "open_targets_disease_targets", {"efo_id": "MONDO_0004992", "size": 25})

open_targets_drug

Drug details by ChEMBL id (Open Targets Platform) — name, type, maximum clinical stage, and mechanisms of action (target + action type). chembl_id e.g. "CHEMBL1201583".

Field	Type	Requirement and constraints
chembl_id	string	required

const result = await host.mcp("clinical-genomics", "open_targets_drug", {"chembl_id": "CHEMBL1201583"})

clinpgx_search_chemicals

Resolve ClinPGx drug/chemical records by ClinPGx accession id or name before querying pharmacogenomic annotations.

Provide at least one of: accessionId / name.

Field	Type	Requirement and constraints
accessionId	string	subject to the conditions above; minLength: 1; pattern: "\S"
name	string	subject to the conditions above; minLength: 1; pattern: "\S"
view	string	optional; default: "base"; enum: ["min", "base", "max"]

const result = await host.mcp("clinical-genomics", "clinpgx_search_chemicals", {"name": "warfarin", "view": "max"})

clinpgx_search_genes

Resolve ClinPGx gene records by ClinPGx accession id or HGNC symbol before querying pharmacogenomic annotations.

Provide at least one of: accessionId / symbol.

Field	Type	Requirement and constraints
accessionId	string	subject to the conditions above; minLength: 1; pattern: "\S"
symbol	string	subject to the conditions above; minLength: 1; pattern: "\S"
view	string	optional; default: "base"; enum: ["min", "base", "max"]

const result = await host.mcp("clinical-genomics", "clinpgx_search_genes", {"symbol": "VKORC1", "view": "max"})

clinpgx_search_summary_annotations

Search ClinPGx clinical annotations linking a drug, gene, and variant. Filter by evidence level 1A, 1B, 2A, 2B, 3, or 4 and retain the original source record.

Provide at least one of: relatedChemicals.accessionId / relatedChemicals.name / location.genes.symbol / location.fingerprint / id.

Field	Type	Requirement and constraints
id	string	subject to the conditions above; minLength: 1; pattern: "\S"
relatedChemicals.accessionId	string	subject to the conditions above; minLength: 1; pattern: "\S"
relatedChemicals.name	string	subject to the conditions above; minLength: 1; pattern: "\S"
location.genes.symbol	string	subject to the conditions above; minLength: 1; pattern: "\S"
location.fingerprint	string	subject to the conditions above; minLength: 1; pattern: "\S"
view	string	optional; default: "base"; enum: ["min", "base", "max"]
levelOfEvidence.term	string	optional; enum: ["1A", "1B", "2A", "2B", "3", "4"]

const result = await host.mcp("clinical-genomics", "clinpgx_search_summary_annotations", {"relatedChemicals.name": "warfarin", "location.genes.symbol": "VKORC1", "levelOfEvidence.term": "1A", "view": "max"})

clinpgx_get_summary_annotation

Retrieve one ClinPGx clinical annotation by its numeric ClinPGx record id, including linked drug, gene, variant, phenotype, and evidence level.

Field	Type	Requirement and constraints
id	number	required; minimum: 1
view	string	optional; default: "base"; enum: ["min", "base", "max"]

const result = await host.mcp("clinical-genomics", "clinpgx_get_summary_annotation", {"id": 655385012, "view": "max"})

clinpgx_search_variant_annotations

Search ClinPGx variant annotations by gene symbol or variant fingerprint (commonly an rsID).

Provide at least one of: location.genes.symbol / location.fingerprint.

Field	Type	Requirement and constraints
location.genes.symbol	string	subject to the conditions above; minLength: 1; pattern: "\S"
location.fingerprint	string	subject to the conditions above; minLength: 1; pattern: "\S"
view	string	optional; default: "base"; enum: ["min", "base", "max"]

const result = await host.mcp("clinical-genomics", "clinpgx_search_variant_annotations", {"location.fingerprint": "rs1799853", "view": "max"})

clinpgx_search_guideline_annotations

Search ClinPGx pharmacogenomic dosing guideline annotations from CPIC, DPWG, or PharmGKB/PRO.

Provide at least one of: source / relatedChemicals.accessionId / relatedGenes.accessionId.

Field	Type	Requirement and constraints
source	string	subject to the conditions above; enum: ["cpic", "dpwg", "pro"]
relatedChemicals.accessionId	string	subject to the conditions above; minLength: 1; pattern: "\S"
relatedGenes.accessionId	string	subject to the conditions above; minLength: 1; pattern: "\S"
view	string	optional; default: "base"; enum: ["min", "base", "max"]

const result = await host.mcp("clinical-genomics", "clinpgx_search_guideline_annotations", {"source": "cpic", "relatedGenes.accessionId": "PA267", "view": "max"})

clinpgx_search_drug_labels

Search ClinPGx regulatory pharmacogenomic drug labels from FDA, EMA, PMDA, or Health Canada.

Provide at least one of: source / relatedChemicals.accessionId / relatedChemicals.name / relatedGenes.accessionId / relatedGenes.symbol.

Field	Type	Requirement and constraints
source	string	subject to the conditions above; enum: ["fda", "ema", "pmda", "hcsc"]
relatedChemicals.accessionId	string	subject to the conditions above; minLength: 1; pattern: "\S"
relatedChemicals.name	string	subject to the conditions above; minLength: 1; pattern: "\S"
relatedGenes.accessionId	string	subject to the conditions above; minLength: 1; pattern: "\S"
relatedGenes.symbol	string	subject to the conditions above; minLength: 1; pattern: "\S"
view	string	optional; default: "base"; enum: ["min", "base", "max"]

const result = await host.mcp("clinical-genomics", "clinpgx_search_drug_labels", {"source": "fda", "relatedChemicals.name": "clopidogrel", "view": "max"})

clinpgx_search_variants

Resolve ClinPGx pharmacogenomic variants by dbSNP rsID or another variant symbol.

Field	Type	Requirement and constraints
symbol	string	required; minLength: 1; pattern: "\S"
view	string	optional; default: "base"; enum: ["min", "base", "max"]

const result = await host.mcp("clinical-genomics", "clinpgx_search_variants", {"symbol": "rs1799853", "view": "max"})

clinpgx_get_variant_frequency

Retrieve population variant frequencies reported by ClinPGx for a variant fingerprint such as an rsID.

Field	Type	Requirement and constraints
fp	string	required; minLength: 1; pattern: "\S"

const result = await host.mcp("clinical-genomics", "clinpgx_get_variant_frequency", {"fp": "rs1799853"})

clinpgx_get_drug_gene_variant

Query a pairwise ClinPGx connection between two objects (for example, a drug and a gene) using the shared connection report; provide one identifier for each object. Use summary annotations for a drug-gene-variant clinical annotation.

For this group provide at least one of: object1Id / object1Name / object1Type.

For this group provide at least one of: object2Id / object2Name / object2Type.

Field	Type	Requirement and constraints
object1Id	string	subject to the conditions above; minLength: 1; pattern: "\S"
object1Name	string	subject to the conditions above; minLength: 1; pattern: "\S"
object1Type	string	subject to the conditions above; minLength: 1; pattern: "\S"
object2Id	string	subject to the conditions above; minLength: 1; pattern: "\S"
object2Name	string	subject to the conditions above; minLength: 1; pattern: "\S"
object2Type	string	subject to the conditions above; minLength: 1; pattern: "\S"
view	string	optional; default: "base"; enum: ["min", "base", "max"]

const result = await host.mcp("clinical-genomics", "clinpgx_get_drug_gene_variant", {"object1Name": "warfarin", "object1Type": "chemical", "object2Name": "VKORC1", "object2Type": "gene", "view": "max"})

get_dgidb_gene_drugs

Query DGIdb drug–gene interactions by gene name. One matching record per page, with full interaction sources, source versions, licenses, types, attributes and publication evidence. Names can match multiple records; follow next_cursor explicitly.

Field	Type	Requirement and constraints
name	string	required; minLength: 1; maxLength: 200
after	string	optional; minLength: 1; maxLength: 500

const result = await host.mcp("clinical-genomics", "get_dgidb_gene_drugs", {"name": "BRAF"})

get_dgidb_drug_genes

Query DGIdb drug–gene interactions by drug name. One matching record per page, with full interaction sources, source versions, licenses, types, attributes and publication evidence. Names can match multiple records; follow next_cursor explicitly.

Field	Type	Requirement and constraints
name	string	required; minLength: 1; maxLength: 200
after	string	optional; minLength: 1; maxLength: 500

const result = await host.mcp("clinical-genomics", "get_dgidb_drug_genes", {"name": "IMATINIB"})

Structures & Interactions

Show operations and parameters

emdb_get_entries

Fetch structured metadata records for EMDB cryo-EM 3D map entries. Accepts accessions as 'EMD-1234', 'emd-1234' or '1234'. Each record carries title, structure determination method (singleParticle / helical / tomography / subtomogramAveraging / electronCrystallography), resolution in Angstrom (null for entries with no reported resolution, e.g. raw tomograms) and the resolution method, deposition/release dates, sample and macromolecule/supramolecule names, fitted PDB model IDs (empty list when no model is fitted), primary citation (journal, year, first author, DOI, PMID), map dimensions and voxel size, and status. Obsolete entries report is_obsolete=true plus superseded_by accessions. Unknown accessions come back as {"emdb_id", "error": "not_found"} — never silently dropped. Metadata only; map volumes are never downloaded.

Field	Type	Requirement and constraints
emdb_ids	array of string	required

const result = await host.mcp("structures", "emdb_get_entries", {"emdb_ids": ["EMD-11638", "emd-3061", "1234"]})

emdb_search_entries

Search EMDB with a Solr-style query; complete paged retrieval of compact rows. Query examples: 'title:"apoferritin" AND resolution:[0 TO 1.5]', 'structure_determination_method:"singleParticle"', 'current_status:"REL" AND release_date:[2024-01-01T00:00:00Z TO *]'. Args: query (Solr query string); max_rows (row cap, default 1000). Returns num_found_released (the API's own released-entry count from the facet route — ground truth), rows_retrieved, rows_by_status (REL vs OBS — the search route returns obsolete entries too but they are NOT counted as released), released_complete (true iff every released match was retrieved; false means max_rows truncated the sweep or the counts disagree), and records: compact per-entry rows (emdb_id, title, resolution, structure_determination_method, current_status, release_date, fitted_pdbs) sorted by EMD accession.

Field	Type	Requirement and constraints
query	string	required
max_rows	integer	optional; default: 1000

const result = await host.mcp("structures", "emdb_search_entries", {"query": "title:\"apoferritin\" AND resolution:[0 TO 1.5]", "max_rows": 500})

emdb_get_entry_section

Fetch one detailed metadata section for EMDB entries. Sections: 'publications' — primary citation with complete ordered author list, auxiliary citations, external references (PMID/DOI/ISSN/CSD); 'map' — file, format, data type, dimensions, voxel spacing, origin, axis order, cell, voxel statistics, contour levels, symmetry; 'sample' — per-macromolecule records (type, molecular weight, copies, EC number, source organism + NCBI taxid, sequence cross-refs) and per-supramolecule records; 'imaging' — microscope, voltage, electron source, detector, dose, imaging modes, defocus range, magnification, Cs, cryogen, grid/buffer/vitrification conditions (one record per microscopy session — entries can carry several). Args: emdb_ids (accession list, any of EMD-1234/emd-1234/1234); section (one of publications/map/sample/imaging). Unknown accessions are reported with "error": "not_found". Use emdb_get_entries first when you only need the headline record.

Field	Type	Requirement and constraints
emdb_ids	array of string	required
section	string	required; enum: ["publications", "map", "sample", "imaging"]

const result = await host.mcp("structures", "emdb_get_entry_section", {"emdb_ids": ["EMD-11638"], "section": "imaging"})

emdb_get_validation

Fetch numeric validation-analysis metrics for EMDB entries. Per entry (from the EMDB /analysis route): Q-score, atom inclusion, recommended/predicted/rawmap contour levels, model/mask volumes, model-map ratio, surface metrics — where the validation pipeline has computed them. available_blocks lists every block the validation service returned; sparse payloads (tomograms, model-free or historical entries) yield explicit nulls. Entries with no validation analysis report has_validation_analysis=false — never silently dropped.

Field	Type	Requirement and constraints
emdb_ids	array of string	required

const result = await host.mcp("structures", "emdb_get_validation", {"emdb_ids": ["EMD-11638", "EMD-3061"]})

complexportal_get_complexes

Fetch curated Complex Portal records by CPX accession. Each record: complex AC, recommended/systematic names + synonyms, species and taxid, participant list with stoichiometry (min/max copies), biological role and interactor type, evidence ECO code, GO annotations, and cross-references — the manually curated description of a stable macromolecular complex. Records come back in input order; unknown accessions are listed in not_found rather than silently dropped. For binary interaction evidence (who binds whom in which experiment) use the intact_* tools instead.

Field	Type	Requirement and constraints
complex_acs	array of string	required

const result = await host.mcp("structures", "complexportal_get_complexes", {"complex_acs": ["CPX-2158", "CPX-2419"]})

complexportal_search_by_participant

Search Complex Portal for complexes containing a molecule. accession is a participant accession — UniProt (e.g. 'P04637'), ChEBI, or RNAcentral. With participants_only=true (default) the search is field-qualified (pxref:<accession>) so only complexes that actually contain the molecule as a curated participant are returned; with false the bare accession is matched as free text too (descriptions, names), which over-reports but can catch mentions. All result pages are retrieved and the row count is verified against the service-reported total (total_reported == total_retrieved, or the call fails loudly). Hits are compact records (complex_ac, name, species, interactors) sorted by complex accession; fetch full detail with complexportal_get_complexes.

Field	Type	Requirement and constraints
accession	string	required
participants_only	boolean	optional; default: true

const result = await host.mcp("structures", "complexportal_search_by_participant", {"accession": "P69905", "participants_only": true})

intact_fetch_interactions

Retrieve ALL IntAct binary interactions matching a query, MI-score filtered. query is a UniProt accession (e.g. 'P04637'), gene symbol, free text, or any IntAct Solr query. Retrieval is a complete paginated sweep verified against the server-reported total (n_records == total_elements, or the call FAILS LOUDLY — silent truncation is impossible). min_mi_score/max_mi_score filter server-side on the IntAct MI confidence score (0.45 is a common medium-confidence floor); interactor_species filters by species name or taxid (e.g. ["Homo sapiens"] or ["9606"]). Records are slim and structured: interactor pair (IntAct ACs, database identifiers, molecule names, species/taxids), interaction type, detection method (+MI id), experimental roles, host organism, MI score, PubMed id, first author, source database — sorted by DESCENDING MI score. Output lists at most max_records_returned records (records_truncated=true when the full verified sweep was larger; n_records always reports the true total). Large queries (e.g. CFTR ~10k interactions) take a while — narrow with min_mi_score or species when possible.

Field	Type	Requirement and constraints
query	string	required
min_mi_score	number	optional; default: 0
max_mi_score	number	optional; default: 1
interactor_species	array of string	optional
max_records_returned	integer	optional; default: 500

const result = await host.mcp("structures", "intact_fetch_interactions", {"query": "P04637", "min_mi_score": 0.45, "interactor_species": ["Homo sapiens"], "max_records_returned": 200})

intact_get_interactor

Resolve a molecule to its IntAct interactor record(s). query is a UniProt accession, gene symbol, or IntAct interactor AC (e.g. 'EBI-7090529'). Returns ALL matching interactor records with an explicit n_matches — a UniProt accession can resolve to the canonical protein plus chain/isoform interactors, and this tool never silently picks one. Each record: interactor_ac, preferred_identifier, name, species, taxid, interactor_type, and the interaction_count seen by IntAct (useful for sizing an intact_fetch_interactions sweep).

Field	Type	Requirement and constraints
query	string	required

const result = await host.mcp("structures", "intact_get_interactor", {"query": "P04637"})

intact_get_interaction_details

Full curated detail for ONE IntAct interaction AC (e.g. 'EBI-15635490'). Returns interaction type, host organism, detection method, publication, cross-references, annotations, kinetic/affinity parameters and confidences, plus per-participant records (identifier, species, biological and experimental role, participant detection methods) unless include_participants=false. Get interaction ACs from intact_fetch_interactions records (the interaction_ac field). Unknown ACs return { interaction_ac, error: 'not_found' }.

Field	Type	Requirement and constraints
interaction_ac	string	required
include_participants	boolean	optional; default: true

const result = await host.mcp("structures", "intact_get_interaction_details", {"interaction_ac": "EBI-15635490", "include_participants": true})

intact_build_network

Build a depth-1 IntAct interaction network around seed proteins. seed_accessions are UniProt accessions. Step 1: a complete, count-verified MI-score-filtered interaction sweep per seed. Step 2: the partners of every seed edge plus the seeds form the node set. Step 3: partner-partner edges are only discoverable by querying the partners themselves, so up to max_interactors_expanded partners are queried (most-connected first, ties by identifier) and edges with BOTH endpoints inside the node set are kept. The expansion block reports exactly which partners were / were not expanded (expansion.complete=false means more partner-partner edges may exist). Output: nodes, edges (with MI score, detection method, PubMed id), per-seed sweep stats. Keep seeds few and min_mi_score >= 0.45 — every expansion is a full paginated sweep.

Field	Type	Requirement and constraints
seed_accessions	array of string	required
min_mi_score	number	optional; default: 0.45
max_interactors_expanded	integer	optional; default: 25
interactor_species	array of string	optional

const result = await host.mcp("structures", "intact_build_network", {"seed_accessions": ["P04637", "Q00987"], "min_mi_score": 0.45, "max_interactors_expanded": 25})

pdb_search_structures

Search RCSB PDB entries by attribute filters; paged, capped + flagged. All filters AND together; at least one is required. text is a full-text relevance query ('p53 DNA binding domain'); organism is an exact source-organism lineage name ('Homo sapiens' — matches at any lineage level, so 'Eukaryota' works too); taxonomy_id an NCBI taxid (9606); uniprot_accession finds entries whose polymer entities map to that UniProt ('P04637' -> every p53 structure); experimental_method is the PDB vocabulary ('X-RAY DIFFRACTION', 'ELECTRON MICROSCOPY', 'SOLUTION NMR', ... — case-insensitive, unknown values error with the full list); max_resolution_angstrom keeps entries at or below that resolution; ligand_comp_id requires a bound nonpolymer component by chem-comp id ('ZN', 'ATP', 'HEM'). include_computed_models=true adds computed structure models (e.g. AlphaFold) to the default experimental-only results. Returns total_count (the API's own match total — ground truth), n_retrieved, truncated (true iff total_count > n_retrieved; max_rows, 1..1000, caps retrieval), and records [{pdb_id, score}] in relevance order. Identifiers only — chain to pdb_get_structures for metadata.

Field	Type	Requirement and constraints
text	string	optional
organism	string	optional
taxonomy_id	integer	optional
uniprot_accession	string	optional
experimental_method	string	optional
max_resolution_angstrom	number	optional
ligand_comp_id	string	optional
include_computed_models	boolean	optional; default: false
max_rows	integer	optional; default: 100

const result = await host.mcp("structures", "pdb_search_structures", {"uniprot_accession": "P04637", "experimental_method": "X-RAY DIFFRACTION", "max_rows": 50})

pdb_get_structures

Fetch entry-level summaries for PDB entries (batch, max 25 ids). Accepts 4-character PDB ids in any case ('1tup' == '1TUP'; duplicates are de-duplicated). Each record: title, experimental methods, resolution in Angstrom (null for methods without one, e.g. NMR), determination methodology (experimental vs computational), deposit/release/revision dates and status, molecular weight (kDa), assembly and entity counts (protein/DNA/RNA polymer + nonpolymer), bound ligand chem-comp ids, polymer/nonpolymer entity id lists (inputs for pdb_get_entities / pdb_get_ligands), and the primary citation (title, journal, year, authors, PubMed id, DOI). Unknown ids come back as {"pdb_id", "error": "not_found"} — never silently dropped. Metadata only; coordinate files are never downloaded.

Field	Type	Requirement and constraints
pdb_ids	array of string	required

const result = await host.mcp("structures", "pdb_get_structures", {"pdb_ids": ["1TUP", "1tup", "6XYZ"]})

pdb_get_entities

Polymer entity details for one PDB entry, incl. UniProt mappings. With entity_ids=null every polymer entity of the entry is fetched, capped at 25 with truncated=true and n_polymer_entities reporting the entry's true count (large assemblies like ribosomes carry 50+ — get the full id list from pdb_get_structures' polymer_entity_ids and page with explicit subsets like ["26", "27"]); with an explicit entity_ids subset the entry total is not fetched, so n_polymer_entities is null; an explicit entity_ids list larger than 25 errors. Each record: description, polymer type (Protein / DNA / RNA), sequence length, mutation count, deposited copies, chain ids (asym + author), source organisms with taxids, UniProt accessions with per-entity sequence coverage (SIFTS), and UniProt-aligned regions (entity-seq vs reference-seq coordinates). Unknown entity ids are listed in not_found; an unknown entry id errors. include_sequences=true adds the canonical one-letter sequence per entity; if the combined sequences exceed max_bytes (default 400000) they are omitted and sequences_omitted explains why — metadata always survives.

Field	Type	Requirement and constraints
pdb_id	string	required
entity_ids	array of string	optional
include_sequences	boolean	optional; default: false
max_bytes	integer	optional; default: 400000

const result = await host.mcp("structures", "pdb_get_entities", {"pdb_id": "1TUP", "include_sequences": true})

pdb_get_ligands

Bound ligands (nonpolymer components) of one PDB entry, with chemistry. Walks the entry's nonpolymer entities and resolves each chemical component: per ligand — entity id, chem-comp id ('ZN', 'ATP'), description, deposited copy count, author chain ids, and a chem_comp block (name, formula, formula weight, formal charge, component type, InChIKey, stereo SMILES). Waters are not nonpolymer entities in the PDB data model and never appear. Entries with no ligands return ligands: []. n_nonpolymer_entities is the entry's true count; truncated=true when it exceeds max_ligands (clamped to 1..25, which bounds the request budget) — never silently dropped. Entities/components the data API no longer serves are reported inline with "error": "not_found" (partial results, not an aborted call). An unknown entry id errors.

Field	Type	Requirement and constraints
pdb_id	string	required
max_ligands	integer	optional; default: 25

const result = await host.mcp("structures", "pdb_get_ligands", {"pdb_id": "1TUP"})

alphafold_get_prediction

AlphaFold DB predicted-structure metadata for one UniProt accession. Returns has_model, n_models and per-model records. A single accession can carry several models (canonical + isoforms like 'P04637-9', and community providers beyond the Google DeepMind monomer pipeline — provider_id / tool_used identify them). Each model: entry id, UniProt annotation (id, description, gene, organism, taxid, reviewed flags), sequence coordinates and length, global pLDDT (global_plddt, 0-100) plus the fraction of residues per pLDDT confidence bin (very_low <50, low 50-70, confident 70-90, very_high >90), model version info and creation date, and download URLs (cif/bcif/pdb coordinates, PAE JSON + image, per-residue pLDDT JSON, MSA, AlphaMissense CSV where available) — URLs only, payloads are never downloaded; fetch them yourself if needed. Accessions without a prediction return has_model=false (not an error); malformed identifiers return an explicit error field. include_sequence=true adds the model sequence (protein one-letter).

Field	Type	Requirement and constraints
uniprot_accession	string	required
include_sequence	boolean	optional; default: false

const result = await host.mcp("structures", "alphafold_get_prediction", {"uniprot_accession": "P04637"})

alphafold_check_coverage

Batch AlphaFold DB coverage check (max 40 unique UniProt accessions). Blank entries and duplicates are stripped before the batch cap applies, and disclosed: n_requested == n_unique + n_blank_skipped + n_duplicate_skipped always reconciles. One compact record per unique accession, in input order: has_model, n_models, and the primary (first-listed) model's model_entity_id, latest_version, global_plddt and sequence_length. Accessions with no prediction report has_model=false; malformed ones carry an explicit error field — never silently dropped. Use to triage which proteins of a set have usable predicted structures before pulling full records with alphafold_get_prediction.

Field	Type	Requirement and constraints
uniprot_accessions	array of string	required

const result = await host.mcp("structures", "alphafold_check_coverage", {"uniprot_accessions": ["P04637", "P38398", "Q9Y6K9"]})

pdb_search_sequence

Find experimental PDB protein entities from one ungapped protein sequence (25..10000 amino acids, raw or single-record FASTA; whitespace and lowercase accepted). Sequence similarity uses RCSB MMseqs2 sequence identity: identity_cutoff is a fraction 0..1, not a percentage; evalue_cutoff is the maximum E-value. min_query_coverage (0..1) filters each alignment locally using (query_end - query_beg + 1) / input sequence length; a hit needs one alignment meeting the cutoff, and only qualifying alignments are returned. This is sequence coverage, not experimentally resolved residue coverage. Scans at most max_candidates (default 100, max 1000) upstream hits in relevance order, then returns at most max_rows (default 10, max 25) entities with chain IDs and match metrics. total_count is the upstream total BEFORE coverage filtering; n_matched counts qualifying entities only among scanned candidates. truncated means more upstream candidates or qualifying records remain. Increase max_candidates to examine lower-ranked hits. Chain IDs list all deposited copies of the matching entity: asym_ids are label IDs, auth_asym_ids are author IDs. Metadata 404s retain the match with metadata_error=not_found and null chain IDs. Relevance score is not sequence identity. Experimental structures only; chain to pdb_get_structures for entry metadata. No coordinate files are downloaded.

Field	Type	Requirement and constraints
sequence	string	required; minLength: 25; maxLength: 50000
identity_cutoff	number	optional; default: 0.3; minimum: 0; maximum: 1
evalue_cutoff	number	optional; default: 0.1; exclusiveMinimum: 0
min_query_coverage	number	optional; default: 0; minimum: 0; maximum: 1
max_candidates	integer	optional; default: 100; minimum: 1; maximum: 1000
max_rows	integer	optional; default: 10; minimum: 1; maximum: 25

const result = await host.mcp("structures", "pdb_search_sequence", {"sequence": "MTEYKLVVVGAGGVGKSALTIQLIQNHFVDEYDPTIEDSYRKQV", "identity_cutoff": 0.9, "min_query_coverage": 0.8, "max_rows": 10})

omnipath_query_regulation

Query directed, signed human protein regulation from OmniPath. Provide one canonical human UniProt accession (resolve names with the Genes connector first). Partner nodes may be proteins or native COMPLEX: identifiers; never expand complexes into inferred pairwise edges. upstream returns sources regulating the queried target; downstream returns targets regulated by the queried source. Both stimulation and inhibition can be true: preserve conflicting evidence and separate consensus flags. Uses the omnipath dataset and the upstream commercial license filter; original resource terms still apply. Relations and citations aggregate multiple sources and biological contexts, not tissue-specific causal proof. Results use upstream order, not confidence ranking; limited results are not the complete network. No pagination or bulk download.

Field	Type	Requirement and constraints
accession	string	required; pattern: "^(?:[OPQ][0-9][A-Z0-9]{3}[0-9]|[A-NR-Z][0-9](?:[A-Z][A-Z0-9]{2}[0-9]){1,2})$"
direction	string	required; enum: ["upstream", "downstream"]
limit	integer	optional; default: 10; minimum: 1; maximum: 50

const result = await host.mcp("structures", "omnipath_query_regulation", {"accession": "P00533", "direction": "upstream", "limit": 10})

pdb_search_structure_similarity

Find experimental PDB protein chains similar in 3D to one deposited PDB chain using the RCSB structure-informed embedding search with global matching, predicted TM-score cutoff 0.8 and 10,000 candidates. Supply a four-character PDB ID and label_asym_id (RCSB/mmCIF chain ID, not the author chain ID; available from pdb_get_entities). Returns top ranked chain identifiers and upstream scores; the query chain may appear among hits. No coordinate upload, structural alignment, RMSD or locally computed TM-score.

Field	Type	Requirement and constraints
pdb_id	string	required; pattern: "^[1-9][A-Za-z0-9]{3}$"
label_asym_id	string	required; minLength: 1; maxLength: 16; pattern: "^[A-Za-z0-9]+$"
max_rows	integer	optional; default: 10; minimum: 1; maximum: 50

const result = await host.mcp("structures", "pdb_search_structure_similarity", {"pdb_id": "1CLL", "label_asym_id": "A", "max_rows": 10})

pdbe_get_validation

Get PDBe quality scores and key validation statistics for one experimental PDB entry. Includes the experimental method. Preserve null metrics and unknown experimental-data availability; missing metrics are not zero or evidence of poor quality. Scores are upstream summaries, not a universal ranking across experimental methods. No predicted models or residue-level reports.

Field	Type	Requirement and constraints
pdb_id	string	required; maxLength: 4; pattern: "^[1-9][A-Za-z0-9]{3}$"

const result = await host.mcp("structures", "pdbe_get_validation", {"pdb_id": "1cbs"})

ChEMBL

Show operations and parameters

compound_search

Search ChEMBL chemical compounds by name (default), ChEMBL id, or molecular structure. By name: case-insensitive synonym substring match (falls back to a preferred-name match). By chembl_id: direct record lookup. By smiles: Tanimoto similarity search when similarity_threshold is set, else a substructure search (structure walks are capped and disclose walk_truncated/upstream_total). Optional max_phase filters by clinical stage. Pass at least one of name, chembl_id, or smiles. Use drug_search instead when searching by therapeutic indication.

Field	Type	Requirement and constraints
name	string	optional
chembl_id	string	optional
smiles	string	optional
similarity_threshold	integer	optional; minimum: 70; maximum: 100
max_phase	integer	optional; enum: [0, 1, 2, 3, 4]
limit	integer	optional; default: 20; minimum: 1; maximum: 1000

const result = await host.mcp("chembl", "compound_search", {"name": "aspirin", "limit": 5})

drug_search

Search approved drugs and clinical candidates by therapeutic indication (EFO term, partial match). Joins drug_indication rows to distinct parent molecules, then to molecule records and withdrawal/black-box warnings. only_approved restricts to phase 4. Optional post-filters molecule_chembl_id, drug_name (preferred-name substring), and max_phase (>=) narrow the joined set. Use compound_search for name/id/structure lookups.

Field	Type	Requirement and constraints
indication	string	required
drug_name	string	optional
molecule_chembl_id	string	optional
max_phase	integer	optional; enum: [0, 1, 2, 3, 4]
only_approved	boolean	optional; default: false
limit	integer	optional; default: 20; minimum: 1; maximum: 1000

const result = await host.mcp("chembl", "drug_search", {"indication": "hypertension", "only_approved": true, "limit": 10})

get_admet

Retrieve ChEMBL calculated molecular properties for drug-likeness / ADMET assessment of one molecule (ALogP, molecular weight, PSA, HBA/HBD, rotatable bonds, aromatic rings, heavy atoms, Rule-of-5 violations, Rule-of-3 pass, QED, molecular formula). These are computed from structure, not experimental measurements.

Field	Type	Requirement and constraints
molecule_chembl_id	string	required

const result = await host.mcp("chembl", "get_admet", {"molecule_chembl_id": "CHEMBL25"})

get_bioactivity

Retrieve ChEMBL bioactivity measurements (IC50, Ki, Kd, EC50, ...) for compound-target interactions. Filter by molecule_chembl_id, target_chembl_id, and/or assay_chembl_id, activity_type (standard_type), a pChEMBL floor (min_pchembl), a standard_value range (min_value/max_value), and unit (standard_units). Returns one page ordered by activity_id with a page-local most-potent summary. Pass next_offset as offset with the same filters to continue beyond 1,000 records; stop when has_more is false. Use get_assay to inspect experimental context before comparing measurements.

Field	Type	Requirement and constraints
molecule_chembl_id	string	optional
target_chembl_id	string	optional
assay_chembl_id	string	optional; minLength: 1; pattern: "^CHEMBL[0-9]+$"
activity_type	string	optional; enum: ["IC50", "EC50", "Ki", "Kd", "AC50", "GI50", "ED50", "Potency"]
min_pchembl	number	optional; minimum: 0; maximum: 14
min_value	number	optional
max_value	number	optional
unit	string	optional; enum: ["nM", "uM", "mM", "pM", "M"]
limit	integer	optional; default: 20; minimum: 1; maximum: 1000
offset	integer	optional; default: 0; minimum: 0; maximum: 9007199254740991

const result = await host.mcp("chembl", "get_bioactivity", {"molecule_chembl_id":"CHEMBL25","activity_type":"IC50","limit":10})

get_mechanism

Retrieve ChEMBL mechanism-of-action records for approved drugs and clinical candidates. Filter by molecule_chembl_id, target_chembl_id, and/or action_type. When a molecule id yields nothing, retries against the parent molecule so salt-form ids resolve. Returns one page ordered by mec_id with an action-type summary.

Field	Type	Requirement and constraints
molecule_chembl_id	string	optional
target_chembl_id	string	optional
action_type	string	optional; enum: ["INHIBITOR", "AGONIST", "ANTAGONIST", "BLOCKER", "MODULATOR", "OPENER", "ACTIVATOR", "POSITIVE ALLOSTERIC MODULATOR", "NEGATIVE ALLOSTERIC MODULATOR", "PARTIAL AGONIST", "INVERSE AGONIST"]
limit	integer	optional; default: 20; minimum: 1; maximum: 1000

const result = await host.mcp("chembl", "get_mechanism", {"molecule_chembl_id": "CHEMBL25"})

target_search

Search ChEMBL biological targets (proteins, complexes, families, organisms). Filter by target_chembl_id, gene_symbol (exact component-synonym match), target_name (preferred-name substring), organism (substring), and/or target_type. Each result carries its components with UniProt accessions, a gene_symbol, and bounded cross-reference lists.

Field	Type	Requirement and constraints
target_name	string	optional
gene_symbol	string	optional
target_chembl_id	string	optional
organism	string	optional
target_type	string	optional; enum: ["SINGLE PROTEIN", "PROTEIN COMPLEX", "PROTEIN FAMILY", "ORGANISM", "TISSUE", "CELL-LINE", "NUCLEIC-ACID", "SUBCELLULAR"]
limit	integer	optional; default: 20; minimum: 1; maximum: 1000

const result = await host.mcp("chembl", "target_search", {"gene_symbol": "EGFR", "organism": "Homo sapiens", "limit": 5})

get_assay

Retrieve one ChEMBL assay by assay_chembl_id from a bioactivity record. Returns experimental description, assay type and format, organism, cell/tissue context, assay parameters, assigned target and target-assignment confidence. Confidence describes target assignment, not measurement quality; compare assay conditions before combining IC50/Ki values. Use get_bioactivity with the same assay_chembl_id to retrieve its measurements.

Field	Type	Requirement and constraints
assay_chembl_id	string	required; minLength: 1; pattern: "^CHEMBL[0-9]+$"

const result = await host.mcp("chembl", "get_assay", {"assay_chembl_id":"CHEMBL1217643"})

bioRxiv

Show operations and parameters

get_categories

List all 27 bioRxiv subject categories and their API-compatible slugs (e.g. "cancer biology" -> "cancer_biology"). Use before search_preprints to discover valid category values.

Field	Type	Requirement and constraints
—	object	No fields; pass an empty object.

const result = await host.mcp("biorxiv", "get_categories", {})

search_preprints

Search bioRxiv/medRxiv preprints by date and (optionally) category. Use exactly ONE search method: date_from+date_to, recent_days (last N days), or recent_count (N most recent within a 90-day window); with none, the last 60 days. There is NO keyword/text search. cursor paginates. Returns DOI, title, authors, date, category, version, and a 200-char abstract preview.

Field	Type	Requirement and constraints
server	string	optional; default: "biorxiv"; enum: ["biorxiv", "medrxiv"]
category	string	optional; enum: ["animal behavior and cognition", "biochemistry", "bioengineering", "bioinformatics", "biophysics", "cancer biology", "cell biology", "clinical trials", "developmental biology", "ecology", "epidemiology", "evolutionary biology", "genetics", "genomics", "immunology", "microbiology", "molecular biology", "neuroscience", "paleontology", "pathology", "pharmacology and toxicology", "physiology", "plant biology", "scientific communication and education", "synthetic biology", "systems biology", "zoology"]
date_from	string	optional
date_to	string	optional
recent_days	integer	optional; minimum: 1
recent_count	integer	optional; minimum: 1
limit	integer	optional; default: 10; minimum: 1; maximum: 100
cursor	integer	optional; default: 0; minimum: 0

const result = await host.mcp("biorxiv", "search_preprints", {"recent_days": 30, "category": "neuroscience", "limit": 20})

get_preprint

Get complete metadata for one preprint by DOI (bare "10.1101/..." or a full https://doi.org/ URL). Uses the latest version. Returns title, authors, corresponding author + institution, full abstract, category, license, version, JATS XML, funding, published journal DOI (if linked), PDF and web URLs, and version count. Preprints are NOT peer-reviewed.

Field	Type	Requirement and constraints
doi	string	required
server	string	optional; default: "biorxiv"; enum: ["biorxiv", "medrxiv"]

const result = await host.mcp("biorxiv", "get_preprint", {"doi": "10.1101/339747"})

search_published_preprints

Find preprints that were later published in peer-reviewed journals (preprint -> journal-article links). Same ONE-OF search methods as search_preprints (date_from+date_to / recent_days / recent_count). include_details=false returns a compact summary. publisher filters by journal DOI prefix (e.g. "10.1038" for Nature) via the bioRxiv-only /publisher route.

Field	Type	Requirement and constraints
server	string	optional; default: "biorxiv"; enum: ["biorxiv", "medrxiv"]
publisher	string	optional
include_details	boolean	optional; default: true
date_from	string	optional
date_to	string	optional
recent_days	integer	optional; minimum: 1
recent_count	integer	optional; minimum: 1
limit	integer	optional; default: 10; minimum: 1; maximum: 100
cursor	integer	optional; default: 0; minimum: 0

const result = await host.mcp("biorxiv", "search_published_preprints", {"publisher": "10.1038", "date_from": "2024-01-01", "date_to": "2024-01-05", "limit": 10})

search_by_funder

Find preprints acknowledging a funder, identified by ROR id (9-char, e.g. "021nxhr62" for NIH; a full https://ror.org/ URL is also accepted). Requires an explicit date_from + date_to; funder metadata begins 2025-04-10. Optional category filter. cursor paginates. Same compact result shape as search_preprints.

Field	Type	Requirement and constraints
funder_ror_id	string	required
date_from	string	required
date_to	string	required
server	string	optional; default: "biorxiv"; enum: ["biorxiv", "medrxiv"]
category	string	optional; enum: ["animal behavior and cognition", "biochemistry", "bioengineering", "bioinformatics", "biophysics", "cancer biology", "cell biology", "clinical trials", "developmental biology", "ecology", "epidemiology", "evolutionary biology", "genetics", "genomics", "immunology", "microbiology", "molecular biology", "neuroscience", "paleontology", "pathology", "pharmacology and toxicology", "physiology", "plant biology", "scientific communication and education", "synthetic biology", "systems biology", "zoology"]
limit	integer	optional; default: 10; minimum: 1; maximum: 100
cursor	integer	optional; default: 0; minimum: 0

const result = await host.mcp("biorxiv", "search_by_funder", {"funder_ror_id": "021nxhr62", "date_from": "2025-04-10", "date_to": "2025-05-10", "limit": 10})

get_content_statistics

bioRxiv submission statistics over all history — new vs revised paper counts per period, with running cumulative totals. interval is "monthly" (default) or "yearly".

Field	Type	Requirement and constraints
interval	string	optional; default: "monthly"; enum: ["monthly", "yearly"]

const result = await host.mcp("biorxiv", "get_content_statistics", {"interval": "yearly"})

get_usage_statistics

bioRxiv usage/engagement statistics over all history — abstract views, full-text views, and PDF downloads per period, with running cumulative totals. interval is "monthly" (default) or "yearly".

Field	Type	Requirement and constraints
interval	string	optional; default: "monthly"; enum: ["monthly", "yearly"]

const result = await host.mcp("biorxiv", "get_usage_statistics", {"interval": "yearly"})

Drug Regulatory

Show operations and parameters

search_drug_applications

Search Drugs@FDA applications (NDA/ANDA/BLA) by any combination of exact-phrase filters (brand, generic, active_ingredient, sponsor, marketing_status, dosage_form, route, pharm_class). generic and pharm_class query the harmonized openfda block (absent on older applications, so silently skipped there). A broad search returns the first max_records with the true total and truncated=true; to page beyond ~26,000 records, narrow with submission_date_from/to.

Field	Type	Requirement and constraints
brand	string	optional
generic	string	optional
active_ingredient	string	optional
sponsor	string	optional
marketing_status	string	optional; enum: ["Prescription", "Over-the-counter", "Discontinued", "None (Tentative Approval)"]
dosage_form	string	optional
route	string	optional
pharm_class	string	optional
pharm_class_type	string	optional; enum: ["epc", "moa", "cs", "pe"]
search_type	string	optional; default: "and"; enum: ["and", "or"]
submission_date_from	string	optional
submission_date_to	string	optional
raw_search	string	optional
max_records	integer	optional; default: 50

const result = await host.mcp("drug-regulatory", "search_drug_applications", {"generic": "ATORVASTATIN CALCIUM", "marketing_status": "Prescription", "max_records": 25})

get_drug_application

Fetch one Drugs@FDA application by its number (e.g. "NDA020702", "ANDA076543", "BLA125514"). Returns the full record — sponsor, products (brand, active ingredients + strengths, dosage form, route, marketing status, TE code), complete submissions history, and harmonized openfda fields when present.

Field	Type	Requirement and constraints
application_number	string	required

const result = await host.mcp("drug-regulatory", "get_drug_application", {"application_number": "NDA020702"})

count_drug_applications

Aggregate Drugs@FDA bucket counts over one field, optionally narrowed by the same filters as search_drug_applications. count_field accepts friendly names (sponsor_name, application_number, dosage_form, route, marketing_status, te_code, pharm_class_epc/moa/cs/pe) or a raw openFDA field path (append .exact yourself for analyzed fields).

Field	Type	Requirement and constraints
count_field	string	required
brand	string	optional
generic	string	optional
active_ingredient	string	optional
sponsor	string	optional
marketing_status	string	optional
dosage_form	string	optional
route	string	optional
pharm_class	string	optional
pharm_class_type	string	optional; enum: ["epc", "moa", "cs", "pe"]
search_type	string	optional; default: "and"; enum: ["and", "or"]
submission_date_from	string	optional
submission_date_to	string	optional
raw_search	string	optional
max_buckets	integer	optional; default: 100

const result = await host.mcp("drug-regulatory", "count_drug_applications", {"count_field": "marketing_status"})

get_drug_statistics

Corpus-level Drugs@FDA statistics in one call — total applications, marketing-status split, top dosage forms and routes (with distinct counts), and top sponsors by application count.

Field	Type	Requirement and constraints
—	object	No fields; pass an empty object.

const result = await host.mcp("drug-regulatory", "get_drug_statistics", {})

list_pharmacologic_classes

Enumerate pharmacologic classes with their application counts, counted over the harmonized openfda.pharm_class_<type> block. Counts reflect only applications carrying that block.

Field	Type	Requirement and constraints
class_type	string	optional; default: "epc"; enum: ["epc", "moa", "cs", "pe"]
max_buckets	integer	optional; default: 100

const result = await host.mcp("drug-regulatory", "list_pharmacologic_classes", {"class_type": "epc", "max_buckets": 50})

get_generic_equivalents

Find generic equivalents of a brand drug: resolve the brand to its reference application(s), extract the exact active-ingredient name set(s), then return every Drugs@FDA application with a product whose active-ingredient set matches (including TE codes and marketing status).

Field	Type	Requirement and constraints
brand	string	required

const result = await host.mcp("drug-regulatory", "get_generic_equivalents", {"brand": "Lipitor"})

search_drug_labels

Retrieve FDA drug product labels (SPL) by ingredient/name/route with targeted section extraction. Filters (active_ingredient, generic_name, brand_name, route, product_type) hit the openfda label block; set exact to query the non-analyzed .exact variants. Pass sections to extract raw openFDA label sections instead of the default structured record. raw_search is mutually exclusive with the mapped filters.

Field	Type	Requirement and constraints
active_ingredient	string	optional
generic_name	string	optional
brand_name	string	optional
route	string	optional
product_type	string	optional; enum: ["HUMAN PRESCRIPTION DRUG", "HUMAN OTC DRUG"]
exact	boolean	optional; default: false
raw_search	string	optional
sections	array of string	optional
max_records	integer	optional; default: 25

const result = await host.mcp("drug-regulatory", "search_drug_labels", {"brand_name": "Tylenol", "max_records": 5})

search_drug_adverse_events

Search FAERS reports by reported drug_name (medicinalproduct), harmonized brand/generic/ingredient, reaction, seriousness (1=serious, 2=non-serious), country or initial/latest receipt date. Dates always constrain other filters; raw_search replaces mapped filters but retains dates. Reports can list multiple drugs and reactions and do not establish causation or incidence. Results are capped at 26000; narrow filters for larger cohorts.

Field	Type	Requirement and constraints
drug_name	string	optional
brand_name	string	optional
generic_name	string	optional
ingredient	string	optional
reaction	string	optional
country	string	optional
serious	string	optional
received_date_from	string	optional
received_date_to	string	optional
receipt_date_from	string	optional
receipt_date_to	string	optional
search_type	string	optional; default: "and"; enum: ["and", "or"]
raw_search	string	optional
sort	string	optional
max_records	integer	optional; default: 25; minimum: 1; maximum: 26000

const result = await host.mcp("drug-regulatory", "search_drug_adverse_events", {"drug_name": "LIPITOR", "reaction": "headache", "max_records": 10})

count_drug_adverse_events

Aggregate matching FAERS reports by reaction, drug, outcome, country or receipt date. Counts reflect reports, not incidence or causation; multi-valued buckets overlap and their sum is not a unique report total. Date fields return time/count instead of term/count. raw_search retains date constraints.

Field	Type	Requirement and constraints
count_field	string	required
drug_name	string	optional
brand_name	string	optional
generic_name	string	optional
ingredient	string	optional
reaction	string	optional
country	string	optional
serious	string	optional
received_date_from	string	optional
received_date_to	string	optional
receipt_date_from	string	optional
receipt_date_to	string	optional
search_type	string	optional; default: "and"; enum: ["and", "or"]
raw_search	string	optional
max_buckets	integer	optional; default: 100; minimum: 1; maximum: 1000

const result = await host.mcp("drug-regulatory", "count_drug_adverse_events", {"count_field": "reaction", "drug_name": "LIPITOR"})

search_drug_recalls

Search FDA drug enforcement reports (product recalls) from openFDA by firm, product, recall reason, classification, status, location, or report date.

Field	Type	Requirement and constraints
recalling_firm	string	optional
product_description	string	optional
reason_for_recall	string	optional
status	string	optional
classification	string	optional
city	string	optional
state	string	optional
country	string	optional
report_date_from	string	optional
report_date_to	string	optional
search_type	string	optional; default: "and"; enum: ["and", "or"]
raw_search	string	optional
sort	string	optional
max_records	integer	optional; default: 25; minimum: 1; maximum: 26000

const result = await host.mcp("drug-regulatory", "search_drug_recalls", {"reason_for_recall": "contamination", "max_records": 10})

list_faers_bulk_files

Read the official openFDA drug/event bulk JSON partition manifest. Files remain at their official URLs; no file download, local job or analysis database is created. Reports are not incidence estimates.

Field	Type	Requirement and constraints
offset	integer	optional; default: 0; minimum: 0; maximum: 100000
limit	integer	optional; default: 20; minimum: 1; maximum: 200

const result = await host.mcp("drug-regulatory", "list_faers_bulk_files", {"offset": 0, "limit": 5})

Human Genetics

Show operations and parameters

gwas_associations_for_variant

GWAS Catalog associations reported for one variant (rsID), most significant first. Args: rs_id (dbSNP rsID e.g. rs7412 APOE or rs699 AGT; must be the catalog's current rsID — merged/retired IDs may return zero rows rather than an error); max_records (output cap default 500; trait-hub variants can carry 1000+ associations; rows are server-sorted by p-value ascending, so a capped result is the top-signal prefix). Returns {rs_id, api_total, returned, truncated, associations}. api_total is the catalog's own total; truncated flags a capped fetch. Each association row: {association_id, p_value, pvalue_mantissa, pvalue_exponent, pvalue_description, or_value, beta, ci_lower, ci_upper, range, risk_frequency, snp_effect_alleles, rs_ids, locations, mapped_genes, efo_traits:[{efo_id, efo_trait}], bg_efo_traits, reported_trait, multi_snp_haplotype, snp_interaction, study_accession_id, pubmed_id, first_author}. or_value and beta are mutually exclusive per row (binary vs quantitative); p_value of 0.0 means p < ~1e-308 (use mantissa/exponent).

Field	Type	Requirement and constraints
rs_id	string	required
max_records	integer	optional; default: 500

const result = await host.mcp("human-genetics", "gwas_associations_for_variant", {"rs_id": "rs7412", "max_records": 100})

gwas_associations_for_gene

GWAS Catalog associations whose variants are MAPPED to a gene (catalog's Ensembl pipeline mapping, not author-reported), most significant first. Args: gene_symbol (HGNC symbol, exact match, e.g. PCSK9, APOE; case-sensitive upstream — pass canonical uppercase; intergenic variants map to flanking genes, so rows may sit outside the gene body); max_records (cap default 500; rows server-sorted by p-value ascending). Returns {gene_symbol, api_total, returned, truncated, associations} with the same row shape as gwas_associations_for_variant. A nonexistent symbol returns api_total=0, not an error.

Field	Type	Requirement and constraints
gene_symbol	string	required
max_records	integer	optional; default: 500

const result = await host.mcp("human-genetics", "gwas_associations_for_gene", {"gene_symbol": "PCSK9", "max_records": 100})

gwas_associations_for_trait

GWAS Catalog associations annotated to one EFO trait, most significant first. Args: efo_id (ontology term short form as used by the catalog, e.g. MONDO_0005010, EFO_0004340, HP_0003124; the catalog migrated many historical EFO ids to MONDO/HP — resolve current ids with gwas_search_traits first; pass exactly one of efo_id/efo_trait); efo_trait (exact trait LABEL alternative); max_records (cap default 500; rows p-value ascending). Returns {efo_id|efo_trait, api_total, returned, truncated, associations} with the same row shape as gwas_associations_for_variant. An unknown id/label returns api_total=0, not an error.

Field	Type	Requirement and constraints
efo_id	string	optional
efo_trait	string	optional
max_records	integer	optional; default: 500

const result = await host.mcp("human-genetics", "gwas_associations_for_trait", {"efo_id": "MONDO_0005010", "max_records": 100})

gwas_search_traits

Search GWAS Catalog EFO trait annotations by label substring — the entry point for resolving a disease/phenotype name to the ontology ids that gwas_associations_for_trait / gwas_search_studies take. Args: query (case-insensitive substring of the trait label, e.g. "coronary" matches coronary artery disorder MONDO_0005010 etc.; the catalog mixes EFO, MONDO, HP and OBA ids — don't assume an EFO_ prefix); max_records (cap default 500). Returns {query, api_total, returned, truncated, efo_traits}; each row {efo_id, efo_trait, uri} sorted by label. Count-verified against the catalog's own total when not capped.

Field	Type	Requirement and constraints
query	string	required
max_records	integer	optional; default: 500

const result = await host.mcp("human-genetics", "gwas_search_traits", {"query": "coronary", "max_records": 50})

gwas_search_studies

Search GWAS Catalog studies by trait annotation or publication. Args: efo_id (ontology short form, e.g. MONDO_0005010, resolve via gwas_search_traits; filters combine AND — usually pass one); efo_trait (exact trait label alternative); pubmed_id (PubMed ID of the study's publication, e.g. 38714703); max_records (cap default 500). Returns {filters, api_total, returned, truncated, studies}; each study row {accession_id, disease_trait, efo_traits, bg_efo_traits, pubmed_id, initial_sample_size, replication_sample_size, discovery_ancestry, replication_ancestry, genotyping_technologies, platforms, cohort, full_summary_stats_available, imputed, gxe, gxg}. Count-verified against the catalog total when not capped. At least one filter is required (the unfiltered catalog is ~90k studies).

Field	Type	Requirement and constraints
efo_id	string	optional
efo_trait	string	optional
pubmed_id	string	optional
max_records	integer	optional; default: 500

const result = await host.mcp("human-genetics", "gwas_search_studies", {"efo_id": "MONDO_0005010", "max_records": 50})

gwas_get_study

Fetch one GWAS Catalog study by its GCST accession. Args: accession_id (study accession, e.g. GCST90841394; listed in every association row as study_accession_id and in study search results). Returns {found, accession_id, study} where study is the same row shape as gwas_search_studies (null when the accession is unknown).

Field	Type	Requirement and constraints
accession_id	string	required

const result = await host.mcp("human-genetics", "gwas_get_study", {"accession_id": "GCST90841394"})

gwas_get_variant

Fetch one GWAS Catalog variant record (position, mapped genes, consequence) by rsID — lighter than pulling its associations. Args: rs_id (dbSNP rsID e.g. rs7412). Returns {found, rs_id, variant}; variant is {rs_id, merged, functional_class, most_severe_consequence, alleles (e.g. "C/T (forward)"), mapped_genes, locations:[{chromosome, position, region}], last_update_date} — positions GRCh38 — or null when the rsID is not in the catalog. merged=1 means the rsID was merged into another record upstream.

Field	Type	Requirement and constraints
rs_id	string	required

const result = await host.mcp("human-genetics", "gwas_get_variant", {"rs_id": "rs7412"})

eqtl_list_datasets

List eQTL Catalogue datasets (one dataset = one study x tissue/cell type x quantification method). Args: study_label (exact study name, e.g. GTEx, Alasoo_2018, BLUEPRINT); tissue_label (exact tissue/cell-type label, e.g. liver, macrophage, LCL — lowercase in the catalogue); quant_method (ge=gene expression, exon, tx, txrev, microarray, leafcutter, aptamer=plasma protein; for conventional gene-level eQTLs use ge); max_records (cap default 1000; the full unfiltered catalogue is ~760 datasets). Returns {filters, returned, truncated, datasets} sorted by dataset_id; each {dataset_id (QTD...), study_id (QTS...), study_label, sample_group, tissue_id, tissue_label, condition_label, quant_method, sample_size}. The API publishes no total count; truncated=false proves the listing is complete.

Field	Type	Requirement and constraints
study_label	string	optional
tissue_label	string	optional
quant_method	string	optional
max_records	integer	optional; default: 1000

const result = await host.mcp("human-genetics", "eqtl_list_datasets", {"study_label": "Alasoo_2018", "quant_method": "ge"})

eqtl_associations

Molecular-QTL association rows from one eQTL Catalogue dataset, filtered by gene, variant or region. Args: dataset_id (QTD accession from eqtl_list_datasets, e.g. QTD000266); gene_id (unversioned Ensembl gene ID e.g. ENSG00000130203 APOE; at least one of gene_id/rsid/variant/pos is required); rsid (dbSNP rsID); variant (eQTL Catalogue variant string chr19_44908822_C_T, chr-prefixed underscore GRCh38); pos (genomic window chromosome:start-end GRCh38 no chr prefix, e.g. 19:44900000-44920000); nlog10p_min (significance floor: only rows with -log10(p) >= this, applied upstream); max_records (cap default 1000 = one page). Returns {dataset_id, filters, returned, truncated, associations}; each row {molecular_trait_id, gene_id, variant, rsid, chromosome, position, ref, alt, type, beta, se, pvalue, nlog10p, maf, ac, an, r2, median_tpm}. Rows cover ONLY the cis window the dataset tested (±1 Mb of each gene); empty means "not tested / not present". No total count is published: truncated=false proves exhaustion, truncated=true means the cap was hit.

Field	Type	Requirement and constraints
dataset_id	string	required
gene_id	string	optional
rsid	string	optional
variant	string	optional
pos	string	optional
nlog10p_min	number	optional
max_records	integer	optional; default: 1000

const result = await host.mcp("human-genetics", "eqtl_associations", {"dataset_id": "QTD000266", "gene_id": "ENSG00000130203", "nlog10p_min": 2})

phewas_instances

List the public PheWeb PheWAS portals this server can query, with genome build and capability registry. Returns {instances:{key:{label, base_url, genome_build, capabilities, notes}}}. capabilities name the endpoints each instance exposes: variant (phewas_variant), gene (phewas_finngen_gene), phenotypes (phewas_list_phenotypes), autocomplete (phewas_search_phenotypes). NOTE the build split: FinnGen R12 variant IDs are GRCh38; BioBank Japan (pheweb.jp) is GRCh37/hg19 — liftover coordinates before cross-querying.

Field	Type	Requirement and constraints
—	object	No fields; pass an empty object.

const result = await host.mcp("human-genetics", "phewas_instances", {})

phewas_variant

PheWAS for one variant: its association statistics against every phenotype in a biobank PheWeb portal, most significant first. Args: instance (finngen FinnGen R12 GRCh38, or bbj BioBank Japan GRCh37; variant coords MUST be on the instance's build); variant (chrom-pos-ref-alt, :/_ separators and chr prefix tolerated, e.g. 19-44908822-C-T APOE rs7412 GRCh38/finngen or 1-55505647-G-T PCSK9 rs11591147 GRCh37/bbj); max_phenos (cap default 200; FinnGen returns ~2470 rows; sorted by p-value ascending before capping). Returns {instance, genome_build, variant, variant_meta, total, returned, truncated, phenotypes}; variant_meta {chrom, pos, ref, alt, rsids, nearest_genes, gnomad (FinnGen only)}. Each phenotype row {phenocode, phenostring, category, pval, mlogp, beta, sebeta, af|maf, maf_case, maf_control, n_cases, n_controls, n_samples} (unpublished fields null; BBJ rows have af, FinnGen rows have maf triplets + mlogp). Unknown variants raise a not-found error.

Field	Type	Requirement and constraints
instance	string	required; enum: ["finngen", "bbj"]
variant	string	required
max_phenos	integer	optional; default: 200

const result = await host.mcp("human-genetics", "phewas_variant", {"instance": "finngen", "variant": "19-44908822-C-T", "max_phenos": 50})

phewas_finngen_gene

Gene-level PheWAS from FinnGen R12: for every disease endpoint, the best-associated variant in the gene region, most significant first. Args: gene_symbol (HGNC symbol e.g. PCSK9, APOE; unknown symbols raise a not-found error); max_phenos (cap default 200; FinnGen has 2470 endpoints, one row each; sorted by p-value ascending before capping). Returns {instance:"finngen", genome_build:"GRCh38", gene_symbol, total, returned, truncated, phenotypes}; each row is the phewas_variant row shape plus variant:{chrom, pos, ref, alt, varid, rsids} — the top variant for that endpoint in this gene's region (region != gene body; PheWeb pads gene boundaries). Most rows are null results (pval1) — the per-endpoint BEST variant is still reported; filter by pval yourself for significant hits.

Field	Type	Requirement and constraints
gene_symbol	string	required
max_phenos	integer	optional; default: 200

const result = await host.mcp("human-genetics", "phewas_finngen_gene", {"gene_symbol": "PCSK9", "max_phenos": 50})

phewas_list_phenotypes

Complete phenotype (disease endpoint) catalogue of a PheWeb instance, with case/control counts. Args: instance (currently only finngen exposes this endpoint; BBJ does not — use phewas_search_phenotypes there); max_records (cap default 3000 > FinnGen's ~2470 endpoints, so the default returns the complete catalogue). Returns {instance, total, returned, truncated, phenotypes} sorted by phenocode; each row {phenocode (e.g. "T2D"), phenostring, category, num_cases, num_controls, num_gw_significant (count of genome-wide-significant loci for that endpoint)}.

Field	Type	Requirement and constraints
instance	string	optional; default: "finngen"; enum: ["finngen"]
max_records	integer	optional; default: 3000

const result = await host.mcp("human-genetics", "phewas_list_phenotypes", {"instance": "finngen", "max_records": 3000})

phewas_search_phenotypes

Search a PheWeb instance's phenotypes (and entities) by name — the entry point for resolving a disease name to a phenocode. Args: query (free-text phenotype query e.g. "diabetes", "asthma"; matches phenotype names/codes; some instances also match gene names and rsIDs); instance (finngen default or bbj — both expose autocomplete); max_records (cap default 500; autocomplete responses are short lists, rarely capped). Returns {instance, query, total, returned, truncated, matches}; each match {display, phenocode, url}. Use the phenocode with phewas_list_phenotypes rows or the instance website; BBJ display strings embed the code in parentheses.

Field	Type	Requirement and constraints
query	string	required
instance	string	optional; default: "finngen"; enum: ["finngen", "bbj"]
max_records	integer	optional; default: 500

const result = await host.mcp("human-genetics", "phewas_search_phenotypes", {"query": "diabetes", "instance": "finngen"})

gwas_get_summary_statistics

Inspect the complete GWAS Catalog summary-statistics package for one GCST accession without downloading the potentially huge data files. Returns found=false when the accession has no FTP directory; otherwise returns the HTTPS FTP directory, original and harmonised file listings, parsed -meta.yaml records, the genome assemblies and harmonisation references declared by those records, and the current GWAS-SSF standard column definitions. The column definitions describe the standard, not an observed header from a compressed data file. Use the returned file URLs to download a selected full dataset. Args: accession_id (GCST accession, e.g. GCST90000123); metadata_file (optional exact YAML filename to limit metadata parsing and both reference summaries; the file listing remains complete). The FTP directory is derived from the accession’s thousand-study bucket; malformed YAML or an unreadable existing directory remains an upstream error.

Field	Type	Requirement and constraints
accession_id	string	required
metadata_file	string	optional; minLength: 1

const result = await host.mcp("human-genetics", "gwas_get_summary_statistics", {"accession_id": "GCST90000123"})

Expression

Show operations and parameters

gtex_tissue_sites

List all tissue sites with metadata for a pinned GTEx release (54 in gtex_v8): sample counts, eGene/sGene counts, colour codes, and UBERON ontology ids.

Field	Type	Requirement and constraints
dataset_id	string	optional; default: "gtex_v8"

const result = await host.mcp("expression", "gtex_tissue_sites", {"dataset_id": "gtex_v8"})

gtex_dataset_info

List all GTEx dataset releases with metadata: datasetId, GENCODE version, genome build, dbSNP build, and sample/subject/tissue counts.

Field	Type	Requirement and constraints
dataset_id	string	optional
organization_name	string	optional

const result = await host.mcp("expression", "gtex_dataset_info", {})

gtex_sample_info

Sample and donor metadata for a pinned GTEx release, optionally filtered by tissue_site_detail_id, data_type (e.g. RNASEQ, WGS), or subject_id. Paged and count-verified; an unfiltered call matches tens of thousands of samples, so filter or set max_samples.

Field	Type	Requirement and constraints
tissue_site_detail_id	string	optional
data_type	string	optional
subject_id	string	optional
max_samples	integer	optional
dataset_id	string	optional; default: "gtex_v8"

const result = await host.mcp("expression", "gtex_sample_info", {"tissue_site_detail_id": "Liver", "data_type": "RNASEQ", "max_samples": 100})

gtex_resolve_genes

Resolve gene symbols or unversioned Ensembl ids to versioned GENCODE ids for a pinned release, e.g. GAPDH -> ENSG00000111640.14. Feed the ids to the expression / eQTL tools.

Field	Type	Requirement and constraints
genes	array of string	required
dataset_id	string	optional; default: "gtex_v8"

const result = await host.mcp("expression", "gtex_resolve_genes", {"genes": ["GAPDH", "BRCA2"]})

gtex_median_expression

Median gene expression (TPM) for one or more VERSIONED GENCODE ids across tissues (omit tissues for all). Paged and count-verified over (gene, tissue) rows.

Field	Type	Requirement and constraints
gencode_ids	array of string	required
tissue_site_detail_ids	array of string	optional
dataset_id	string	optional; default: "gtex_v8"

const result = await host.mcp("expression", "gtex_median_expression", {"gencode_ids": ["ENSG00000111640.14"]})

gtex_expression_summary

Summarize a gene’s expression across ALL tissues ranked by descending median TPM. Accepts a symbol or Ensembl id and auto-resolves it to a versioned GENCODE id first.

Field	Type	Requirement and constraints
gene	string	required
dataset_id	string	optional; default: "gtex_v8"

const result = await host.mcp("expression", "gtex_expression_summary", {"gene": "GAPDH"})

gtex_gene_expression

Sample-level (not aggregated) expression TPM arrays for one VERSIONED GENCODE id, per tissue (omit tissues for all). Returns the full per-sample TPM array and n_samples for each tissue.

Field	Type	Requirement and constraints
gencode_id	string	required
tissue_site_detail_ids	array of string	optional
dataset_id	string	optional; default: "gtex_v8"

const result = await host.mcp("expression", "gtex_gene_expression", {"gencode_id": "ENSG00000111640.14", "tissue_site_detail_ids": ["Whole_Blood"]})

gtex_top_expressed_genes

Top-n genes by median TPM in one tissue, using the API-side ranking. filter_mt_gene (default true) drops mitochondrial genes from the ranking.

Field	Type	Requirement and constraints
tissue_site_detail_id	string	required
n	integer	optional; default: 100
filter_mt_gene	boolean	optional; default: true
dataset_id	string	optional; default: "gtex_v8"

const result = await host.mcp("expression", "gtex_top_expressed_genes", {"tissue_site_detail_id": "Whole_Blood", "n": 20})

gtex_eqtl_genes

All eGenes (genes with ≥1 significant cis-eQTL) for a tissue. Walked page-by-page and count-verified (e.g. Pancreas gtex_v8 = 9,660). max_genes caps how many rows are returned.

Field	Type	Requirement and constraints
tissue_site_detail_id	string	required
max_genes	integer	optional
dataset_id	string	optional; default: "gtex_v8"

const result = await host.mcp("expression", "gtex_eqtl_genes", {"tissue_site_detail_id": "Pancreas", "max_genes": 100})

gtex_single_tissue_eqtls

Significant single-tissue cis-eQTL associations for a gene and/or a variant (precomputed). Provide gencode_id and/or variant_id; tissue_site_detail_id optionally narrows. Paged and count-verified.

Field	Type	Requirement and constraints
gencode_id	string	optional
variant_id	string	optional
tissue_site_detail_id	string	optional
max_results	integer	optional
dataset_id	string	optional; default: "gtex_v8"

const result = await host.mcp("expression", "gtex_single_tissue_eqtls", {"gencode_id": "ENSG00000111640.14"})

gtex_multi_tissue_eqtls

Multi-tissue cis-eQTL meta-analysis (METASOFT) for a VERSIONED GENCODE id. variant_id optionally narrows to one variant. Returns per-variant rows with per-tissue m-values, NES, p-values, and SEs.

Field	Type	Requirement and constraints
gencode_id	string	required
variant_id	string	optional
dataset_id	string	optional; default: "gtex_v8"

const result = await host.mcp("expression", "gtex_multi_tissue_eqtls", {"gencode_id": "ENSG00000111640.14"})

gtex_calculate_eqtl

Calculate an eQTL on the fly for any gene-variant pair in one tissue, including non-significant pairs. Returns p-value, NES, t-statistic, MAF, and the per-sample genotype/expression arrays.

Field	Type	Requirement and constraints
gencode_id	string	required
variant_id	string	required
tissue_site_detail_id	string	required
dataset_id	string	optional; default: "gtex_v8"

const result = await host.mcp("expression", "gtex_calculate_eqtl", {"gencode_id": "ENSG00000111640.14", "variant_id": "chr12_6452899_G_A_b38", "tissue_site_detail_id": "Whole_Blood"})

bgee_species

List species available in the Bgee healthy wild-type expression atlas, or retrieve one species by its NCBI taxonomy id. The returned taxon_id identifies that species, even when its reference genome belongs to another species. A list request returns has_expression_data: null because it does not load data-source metadata. Query a specific species_id to check availability; missing metadata also remains null, not false.

Field	Type	Requirement and constraints
species_id	integer	optional; minimum: 1; maximum: 2147483647

const result = await host.mcp("expression", "bgee_species", {})

bgee_expression_calls

Retrieve Bgee present/absent expression calls and normalized expression scores for one gene in one species, preserving anatomical entity and cell type context. Results are healthy wild-type baseline calls and can be capped with max_calls. Missing or unspecified cell types are returned as null.

Field	Type	Requirement and constraints
gene_id	string	required
species_id	integer	required; minimum: 1; maximum: 2147483647
max_calls	integer	optional; default: 100; minimum: 1; maximum: 500
expression_type	string	optional; default: "EXPRESSED"; enum: ["EXPRESSED", "NOT_EXPRESSED"]

const result = await host.mcp("expression", "bgee_expression_calls", {"gene_id": "ENSG00000130208", "species_id": 9606, "max_calls": 50})

bgee_sparql_expression

Run a bounded Bgee SPARQL query for one gene, one NCBI species and one tissue/anatomical entity. All three filters are required; the generated query includes a hard LIMIT and the call has its own timeout.

Field	Type	Requirement and constraints
gene	string	required; minLength: 1; maxLength: 128
species_id	integer	required; minimum: 1; maximum: 2147483647
tissue	string	required; minLength: 1; maxLength: 128
limit	integer	optional; default: 25; minimum: 1; maximum: 100

const result = await host.mcp("expression", "bgee_sparql_expression", {"gene": "APOC1", "species_id": 9606, "tissue": "liver", "limit": 25})

bgee_download_links

Build official Bgee download links for one species: summarized present/absent calls or processed expression-value directories. This returns URLs only and never downloads the large files.

Field	Type	Requirement and constraints
species	string	required; minLength: 1; maxLength: 128
file_kind	string	optional; default: "calls_simple"; enum: ["calls_simple", "calls_advanced", "processed_rna_seq", "processed_affymetrix", "processed_sc_full_length", "processed_sc_droplet_based"]
all_conditions	boolean	optional; default: false

const result = await host.mcp("expression", "bgee_download_links", {"species": "Homo_sapiens", "file_kind": "calls_simple"})

Protein Annotation

Show operations and parameters

get_domain_architecture

Complete InterPro domain architecture for one or more UniProt proteins (all matching entries, member-DB signatures, fragment coordinates), with pagination verified against the API count.

Field	Type	Requirement and constraints
accessions	array of string	required

const result = await host.mcp("protein-annotation", "get_domain_architecture", {"accessions": ["P04637"]})

search_interpro_entries

Keyword search over InterPro or member-database entries (Pfam, SMART, PROSITE, PANTHER, CDD), complete cursor walk verified against the API count.

Field	Type	Requirement and constraints
query	string	optional
entry_type	string	optional
source_db	string	optional; default: "interpro"
go_term	string	optional

const result = await host.mcp("protein-annotation", "search_interpro_entries", {"query": "kinase", "source_db": "pfam"})

get_interpro_entry

Detail record for an InterPro entry (IPRxxxxxx) or Pfam family (PFxxxxx) — route chosen by accession prefix.

Field	Type	Requirement and constraints
accession	string	required

const result = await host.mcp("protein-annotation", "get_interpro_entry", {"accession": "IPR000719"})

search_pfam_clans

Keyword search over Pfam clans (InterPro sets, accessions CLxxxx).

Field	Type	Requirement and constraints
query	string	optional

const result = await host.mcp("protein-annotation", "search_pfam_clans", {"query": "kinase"})

get_pfam_clan

Pfam clan detail including the complete sorted member-family list.

Field	Type	Requirement and constraints
clan_accession	string	required

const result = await host.mcp("protein-annotation", "get_pfam_clan", {"clan_accession": "CL0016"})

get_pfam_family_proteins

Member proteins of a Pfam family (complete count-verified walk or count only). Use count_only for very large families.

Field	Type	Requirement and constraints
pfam_accession	string	required
reviewed_only	boolean	optional; default: false
tax_id	integer	optional
count_only	boolean	optional; default: false

const result = await host.mcp("protein-annotation", "get_pfam_family_proteins", {"pfam_accession": "PF00069", "count_only": true})

get_pfam_family_proteomes

Proteomes containing members of a Pfam family. count_only defaults true — the upstream proteome cursor pagination is defective for deep walks.

Field	Type	Requirement and constraints
pfam_accession	string	required
count_only	boolean	optional; default: true

const result = await host.mcp("protein-annotation", "get_pfam_family_proteomes", {"pfam_accession": "PF00069"})

get_protein_atlas_gene

Human Protein Atlas per-gene record (release 25.x): tissue/subcellular/pathology/blood/brain expression and antibody info. Accepts an Ensembl gene ID or a gene symbol.

Field	Type	Requirement and constraints
gene	string	required
full	boolean	optional; default: false

const result = await host.mcp("protein-annotation", "get_protein_atlas_gene", {"gene": "TP53"})

search_protein_atlas

Column-selected bulk search over the Human Protein Atlas (search_download).

Field	Type	Requirement and constraints
query	string	required
columns	string	optional; default: "g,gs,eg,gd,up,chr,chrp,scl"

const result = await host.mcp("protein-annotation", "search_protein_atlas", {"query": "kinase"})

map_string_ids

Map gene symbols/aliases to STRING protein identifiers (v12.0). Every input symbol is either mapped or listed in unmapped — the two partition the input.

Field	Type	Requirement and constraints
symbols	array of string	required
species	integer	optional; default: 9606

const result = await host.mcp("protein-annotation", "map_string_ids", {"symbols": ["TP53", "BRCA1", "EGFR"]})

get_string_network

STRING protein-protein interaction network for a gene list (v12.0) at a confidence threshold. Maps symbols first (unmapped reported), then retrieves nodes, edges, summary and provenance. A single mapped input requests 10 interaction neighbors, matching STRING; multiple mapped inputs are not expanded.

Field	Type	Requirement and constraints
symbols	array of string	required
species	integer	optional; default: 9606
required_score	integer	optional; default: 700

const result = await host.mcp("protein-annotation", "get_string_network", {"symbols": ["TP53", "BRCA1", "EGFR"], "required_score": 700})

get_string_similarity_scores

Smith-Waterman protein similarity bitscores among a gene set (STRING /homology). Sparse: pairs absent from STRING's data are not listed (absence means no recorded similarity, not zero).

Field	Type	Requirement and constraints
symbols	array of string	required
species	integer	optional; default: 9606

const result = await host.mcp("protein-annotation", "get_string_similarity_scores", {"symbols": ["TP53", "MDM2", "MDM4"]})

get_string_best_similarity_hits

Best homology hit per input protein in a target species (STRING /homology_best). target_species=null asks for the best hit across all species.

Field	Type	Requirement and constraints
symbols	array of string	required
species	integer	optional; default: 9606
target_species	integer	optional

const result = await host.mcp("protein-annotation", "get_string_best_similarity_hits", {"symbols": ["TP53"], "target_species": 10090})

get_string_ppi_enrichment

STRING protein-protein interaction enrichment for a gene list (v12.0). Tests whether the mapped proteins have more interactions than expected from the STRING background distribution, with an optional background set of STRING protein IDs.

Field	Type	Requirement and constraints
symbols	array of string	required
species	integer	optional; default: 9606
required_score	integer	optional; default: 400
background_string_ids	array of string	optional

const result = await host.mcp("protein-annotation", "get_string_ppi_enrichment", {"symbols": ["TP53", "BRCA1", "EGFR"], "required_score": 700})

Cancer Models

Show operations and parameters

cbioportal_list_studies

List cBioPortal cancer studies, optionally filtered by a free-text keyword (name/description/cancer type) and/or an exact cancer-type id; returns study id, name, cancer type, reference genome, citation, and per-data-type sample counts.

Field	Type	Requirement and constraints
keyword	string	optional
cancer_type_id	string	optional
max_records	integer	optional; default: 500

const result = await host.mcp("cancer-models", "cbioportal_list_studies", {"keyword": "glioma"})

cbioportal_get_study

Get a cBioPortal cancer study by id: metadata, per-data-type sample counts, true sample/patient counts (from the study collections, not the display field), and its molecular profiles.

Field	Type	Requirement and constraints
study_id	string	required

const result = await host.mcp("cancer-models", "cbioportal_get_study", {"study_id": "msk_impact_2017"})

cbioportal_mutations_in_gene

All mutations of one gene (HUGO symbol) in a cBioPortal study, with recurrence aggregates: total mutations, mutated-sample count, mutation-type and protein-change distributions, and the most recurrent protein changes.

Field	Type	Requirement and constraints
gene_symbol	string	required
study_id	string	required
max_records	integer	optional; default: 100

const result = await host.mcp("cancer-models", "cbioportal_mutations_in_gene", {"gene_symbol": "IDH1", "study_id": "difg_msk_2023"})

cbioportal_mutation_frequency

Mutation frequency of one gene across several cBioPortal studies (1–12): unique mutated samples divided by samples profiled for that gene in the selected mutation profile and sample list, accounting for targeted gene panels; ranked most-frequent first.

Field	Type	Requirement and constraints
gene_symbol	string	required
study_ids	array of string	required; minItems: 1; maxItems: 12

const result = await host.mcp("cancer-models", "cbioportal_mutation_frequency", {"gene_symbol": "KRAS", "study_ids": ["msk_impact_2017", "difg_msk_2023"]})

cbioportal_cna_in_gene

Discrete copy-number alterations of one gene in a cBioPortal study, filtered by event type (deep deletion / amplification by default), with the full per-sample alteration distribution.

Field	Type	Requirement and constraints
gene_symbol	string	required
study_id	string	required
event_type	string	optional; default: "HOMDEL_AND_AMP"; enum: ["HOMDEL_AND_AMP", "HOMDEL", "AMP", "GAIN", "HETLOSS", "DIPLOID", "ALL"]
max_records	integer	optional; default: 100

const result = await host.mcp("cancer-models", "cbioportal_cna_in_gene", {"gene_symbol": "CDKN2A", "study_id": "msk_impact_2017"})

cbioportal_clinical_attributes

Clinical attributes defined in a cBioPortal study (patient- and sample-level fields), highlighting survival endpoints and whether overall-survival data is present.

Field	Type	Requirement and constraints
study_id	string	required
max_records	integer	optional; default: 200

const result = await host.mcp("cancer-models", "cbioportal_clinical_attributes", {"study_id": "brca_tcga_pan_can_atlas_2018"})

cbioportal_get_samples

List cBioPortal samples in a study with detailed sample and patient identifiers. Optional sample_ids restrict the returned rows; max_records caps the response while preserving the true study count.

Field	Type	Requirement and constraints
study_id	string	required; minLength: 1; pattern: "\S"
sample_ids	array of string	optional; minItems: 1; maxItems: 1000
max_records	integer	optional; default: 500; minimum: 1; maximum: 10000

const result = await host.mcp("cancer-models", "cbioportal_get_samples", {"study_id": "brca_tcga_pan_can_atlas_2018", "max_records": 100})

cbioportal_get_patients

List cBioPortal patients in a study with detailed identifiers. Optional patient_ids restrict the returned rows; max_records caps the response while preserving the true study count.

Field	Type	Requirement and constraints
study_id	string	required; minLength: 1; pattern: "\S"
patient_ids	array of string	optional; minItems: 1; maxItems: 1000
max_records	integer	optional; default: 500; minimum: 1; maximum: 10000

const result = await host.mcp("cancer-models", "cbioportal_get_patients", {"study_id": "brca_tcga_pan_can_atlas_2018", "max_records": 100})

cbioportal_get_clinical_data

Fetch cBioPortal clinical data values for explicit patient_ids or sample_ids matching level, optionally restricted to attribute_ids. Clinical values remain strings, including missing-value markers.

Field	Type	Requirement and constraints
study_id	string	required; minLength: 1; pattern: "\S"
level	string	optional; default: "SAMPLE"; enum: ["SAMPLE", "PATIENT"]
attribute_ids	array of string	optional; maxItems: 1000
sample_ids	array of string	optional; minItems: 1; maxItems: 1000
patient_ids	array of string	optional; minItems: 1; maxItems: 1000
max_records	integer	optional; default: 1000; minimum: 1; maximum: 10000

const result = await host.mcp("cancer-models", "cbioportal_get_clinical_data", {"study_id": "brca_tcga_pan_can_atlas_2018", "level": "PATIENT", "attribute_ids": ["AGE"], "patient_ids": ["TCGA-A1-A0SB"]})

cbioportal_get_molecular_data

Fetch numeric mRNA or protein expression values from an explicit study molecular profile. Discover profiles with cbioportal_get_study; choose the measurement/normalization deliberately. Supply gene_symbol or entrez_gene_ids and exactly one of sample_ids or sample_list_id. Missing rows are not zero expression.

Field	Type	Requirement and constraints
study_id	string	required; minLength: 1; pattern: "\S"
molecular_profile_id	string	required; minLength: 1; pattern: "\S"
gene_symbol	string	optional
entrez_gene_ids	array of integer	optional; maxItems: 1000
sample_ids	array of string	optional; minItems: 1; maxItems: 1000
sample_list_id	string	optional; minLength: 1; pattern: "\S"
max_records	integer	optional; default: 1000; minimum: 1; maximum: 10000

const result = await host.mcp("cancer-models", "cbioportal_get_molecular_data", {"study_id": "brca_tcga_pan_can_atlas_2018", "molecular_profile_id": "brca_tcga_pan_can_atlas_2018_rna_seq_v2_mrna", "gene_symbol": "ESR1", "sample_list_id": "brca_tcga_pan_can_atlas_2018_all"})

depmap_search_models

Search DepMap/CCLE cancer models by name substring or exact ACH ModelID and return selected identity, lineage, disease and RRID metadata. Names may match multiple models: retain their distinct ModelIDs. No full model catalog download.

Field	Type	Requirement and constraints
query	string	required; minLength: 2; maxLength: 100; pattern: "\S"
limit	integer	optional; default: 10; minimum: 1; maximum: 20

const result = await host.mcp("cancer-models", "depmap_search_models", {"query": "A549"})

depmap_gene_dependency

Get one exact gene symbol’s DepMap Chronos gene-effect profile, optionally restricted to ModelIDs. Returns the strongest effects first, bounded to 50 models. Missing scores are unknown, not zero; negative gene effects are not dependency probabilities. Includes current dataset release and model annotations; no full matrix download.

Field	Type	Requirement and constraints
gene	string	required; pattern: "^[A-Za-z0-9][A-Za-z0-9._-]{0,59}$"
model_ids	array	optional; minItems: 1; maxItems: 20
limit	integer	optional; default: 20; minimum: 1; maximum: 50

const result = await host.mcp("cancer-models", "depmap_gene_dependency", {"gene": "KRAS", "model_ids": ["ACH-000681"]})

depmap_drug_response

Get one compound’s DepMap PRISM secondary screen AUC profile, optionally restricted to ModelIDs. Accepts an exact DPC compound ID or full compound name (case-insensitive exact match, no fuzzy substitution). Returns lowest AUC first, bounded to 50 models. AUC is not IC50 or viability; missing values stay null. Reports the PRISM release separately from model metadata.

Field	Type	Requirement and constraints
compound	string	required; minLength: 2; maxLength: 100; pattern: "\S"
model_ids	array	optional; minItems: 1; maxItems: 20
limit	integer	optional; default: 20; minimum: 1; maximum: 50

const result = await host.mcp("cancer-models", "depmap_drug_response", {"compound": "trametinib", "model_ids": ["ACH-000681"]})

depmap_gene_expression

Get one exact gene symbol’s current DepMap/CCLE RNA expression profile in log2(TPM+1), optionally restricted to ModelIDs. Returns highest expression first, at most 50 models, with release and model metadata. This is not raw TPM or z-score data. Use depmap_search_models to resolve cell line names to ModelIDs; no full matrix download.

Field	Type	Requirement and constraints
gene	string	required; pattern: "^[A-Za-z0-9][A-Za-z0-9._-]{0,59}$"
model_ids	array	optional; minItems: 1; maxItems: 20
limit	integer	optional; default: 20; minimum: 1; maximum: 50

const result = await host.mcp("cancer-models", "depmap_gene_expression", {"gene": "KRAS", "model_ids": ["ACH-000681"]})

depmap_copy_number

Get one exact gene symbol’s current DepMap/CCLE WGS gene copy-number profile relative to model ploidy, optionally restricted to ModelIDs. Returns highest relative copy number first, at most 50 models, with release and model metadata. Values are not absolute copies, log2 values or discrete amplification/deletion calls. Use depmap_search_models to resolve cell line names to ModelIDs.

Field	Type	Requirement and constraints
gene	string	required; pattern: "^[A-Za-z0-9][A-Za-z0-9._-]{0,59}$"
model_ids	array	optional; minItems: 1; maxItems: 20
limit	integer	optional; default: 20; minimum: 1; maximum: 50

const result = await host.mcp("cancer-models", "depmap_copy_number", {"gene": "MYC", "model_ids": ["ACH-000681"]})

RNA

Show operations and parameters

get_family

Rfam family metadata for an accession (RF00005) or family id (tRNA) — both resolve. Flattened record plus the full upstream JSON in "raw".

Field	Type	Requirement and constraints
family	string	required

const result = await host.mcp("rna", "get_family", {"family": "RF00005"})

get_seed_alignment

Seed alignment of an Rfam family in Stockholm (default, with consensus secondary-structure line) or aligned gapped FASTA.

Field	Type	Requirement and constraints
family	string	required
fmt	string	optional; default: "stockholm"; enum: ["stockholm", "fasta"]
max_bytes	integer	optional; default: 400000

const result = await host.mcp("rna", "get_seed_alignment", {"family": "RF00162", "fmt": "stockholm"})

get_covariance_model

Infernal covariance model (CM file) of an Rfam family, usable directly with cmsearch/cmscan, plus parsed header fields.

Field	Type	Requirement and constraints
family	string	required
max_bytes	integer	optional; default: 400000

const result = await host.mcp("rna", "get_covariance_model", {"family": "RF00162"})

get_tree

Seed phylogenetic tree of an Rfam family (NHX/Newick text).

Field	Type	Requirement and constraints
family	string	required

const result = await host.mcp("rna", "get_tree", {"family": "RF00162"})

get_sequence_regions

All full-region hits of an Rfam family across sequence databases (parsed TSV). Check num_full via get_family first — rfam.org 403s this route for very large families (e.g. RF00005).

Field	Type	Requirement and constraints
family	string	required

const result = await host.mcp("rna", "get_sequence_regions", {"family": "RF00162"})

get_structure_mapping

PDB residue-level structure mappings of an Rfam family, deterministically sorted.

Field	Type	Requirement and constraints
family	string	required

const result = await host.mcp("rna", "get_structure_mapping", {"family": "RF00162"})

accession_to_id

Convert an Rfam accession to its family id (e.g. RF00005 -> "tRNA").

Field	Type	Requirement and constraints
accession	string	required

const result = await host.mcp("rna", "accession_to_id", {"accession": "RF00005"})

id_to_accession

Convert an Rfam family id to its accession (e.g. "tRNA" -> RF00005).

Field	Type	Requirement and constraints
family_id	string	required

const result = await host.mcp("rna", "id_to_accession", {"family_id": "tRNA"})

search_sequence

Search an RNA sequence through the official Rfam batch endpoint. Keep the returned job identity while waiting; an unfinished response is not a zero-hit result. Inspect the completed matches and source information. After a failed response, diagnose or resume the existing job rather than submitting it repeatedly.

Field	Type	Requirement and constraints
sequence	string	required
max_wait_s	number	optional; default: 300
poll_interval_s	number	optional; default: 5

const result = await host.mcp("rna", "search_sequence", {"sequence": "GGUUCCGGGAAGGCAGCAGGUGGAAACCUGCCA"})

get_rnacentral_record

Fetch an RNAcentral sequence record by URS accession using API v1. Retains sequence, MD5, activity status, organism and RNA type metadata.

Field	Type	Requirement and constraints
urs	string	required

const result = await host.mcp("rna", "get_rnacentral_record", {"urs": "URS0000000001"})

get_rnacentral_xrefs

Map an RNAcentral URS accession to one page of expert-database identifiers. Retains source database, taxonomy, accession version, activity and first/last-seen dates; no automatic page traversal.

Field	Type	Requirement and constraints
urs	string	required
page	integer	optional; default: 1; minimum: 1; maximum: 100000
page_size	integer	optional; default: 10; minimum: 1; maximum: 100

const result = await host.mcp("rna", "get_rnacentral_xrefs", {"urs": "URS0000000001", "page": 1, "page_size": 10})

Omics Archives

Show operations and parameters

ena_query_runs

Discover public sequencing runs by NCBI tax_id (including descendant taxa), library_strategy and/or a keyword in study, experiment or sample titles and run descriptions. Supplied filters are combined with AND; at least one is required. Taxonomy describes the sequenced organism, not the host of a microbiome sample. Keyword is a literal substring, not ENA query syntax; double quotes, backslashes, wildcards and control characters are rejected. Includes public metagenome records. Returns bounded metadata only, not a complete cohort when truncated. Narrow filters to retrieve a smaller set; repeated calls are not pagination. For known INSDC accessions use ena_search_runs.

Supply at least one listed search filter; consult the downloadable schema for complete combination rules.

Field	Type	Requirement and constraints
tax_id	integer	optional; minimum: 1; maximum: 2147483647
library_strategy	string	optional; enum: ["AMPLICON", "ATAC-seq", "Bisulfite-Seq", "CLONE", "CLONEEND", "CTS", "ChIA-PET", "ChIP-Seq", "ChM-Seq", "DNase-Hypersensitivity", "EST", "FAIRE-seq", "FINISHING", "FL-cDNA", "GBS", "Hi-C", "MBD-Seq", "MNase-Seq", "MRE-Seq", "MeDIP-Seq", "NOMe-Seq", "OTHER", "POOLCLONE", "RAD-Seq", "RIP-Seq", "RNA-Seq", "Ribo-Seq", "SELEX", "Synthetic-Long-Read", "Targeted-Capture", "Tethered Chromatin Conformation Capture", "Tn-Seq", "VALIDATION", "WCS", "WGA", "WGS", "WXS", "miRNA-Seq", "ncRNA-Seq", "snRNA-seq", "ssRNA-seq"]
keyword	string	optional; minLength: 1; maxLength: 200; pattern: "^(?=[\\s\\S]*\\S)[^\"\\\\*?\\u0000-\\u001f\\u007f]+$"
limit	integer	optional; default: 100; minimum: 1; maximum: 1000

const result = await host.mcp("omics-archives", "ena_query_runs", {"tax_id": 6239, "library_strategy": "RNA-Seq", "keyword": "transcriptome", "limit": 20})

ena_get_submitted_files

List original submitted files for one ERR/SRR/DRR run, including submitted BAM, CRAM or FASTQ when ENA exposes them. Returns FTP locations, submitted formats, byte sizes and MD5 checksums as metadata only. Does not download, convert formats, retrieve reference genomes or verify checksums. These are submitted files, not the archive-generated FASTQ returned by ena_get_run_files and not a list of archive-generated SRA containers. A CRAM may require its matching reference for analysis.

Field	Type	Requirement and constraints
run_accession	string	required; minLength: 1; maxLength: 64

const result = await host.mcp("omics-archives", "ena_get_submitted_files", {"run_accession": "ERR10015065"})

ena_search_runs

Find public sequencing runs associated with one ENA/INSDC study, experiment, sample or run accession. Accepts PRJ/ERP/SRP/DRP, ERX/SRX/DRX, SAM/ERS/SRS/DRS and ERR/SRR/DRR identifiers; GEO GSE/GSM, ArrayExpress E-MTAB and MGnify MGYS identifiers need their linked INSDC accession first. Accession lookup only, not keyword search. Returns organism and library metadata without fetching data files. The result is capped at 1000 runs; a truncated result is not a complete cohort, and repeated calls are not pagination because ENA provides no offset or continuation token. Use a narrower sample or experiment accession when complete coverage is required.

Field	Type	Requirement and constraints
accession	string	required; minLength: 1; maxLength: 64
limit	integer	optional; default: 100; minimum: 1; maximum: 1000

const result = await host.mcp("omics-archives", "ena_search_runs", {"accession": "PRJNA123835", "limit": 100})

ena_get_run_files

Get archive-generated FASTQ download URLs, byte sizes and upstream MD5 checksums for one ERR/SRR/DRR run. Returns a file inventory only; no download or checksum verification. Retains every file in report order, including unpaired or long-read files; library_layout=PAIRED does not imply exactly two files. file_index is positional only and is not an R1/R2 or mate identifier. Some runs (including some single-cell/native-format submissions) have no archive-generated FASTQ. Submitted BAM/CRAM/SRA files are outside this tool.

Field	Type	Requirement and constraints
run_accession	string	required; minLength: 1; maxLength: 64

const result = await host.mcp("omics-archives", "ena_get_run_files", {"run_accession": "SRR037073"})

arrayexpress_search_experiments

Search ArrayExpress functional-genomics experiments (BioStudies) with complete, totalHits-verified retrieval; filters (query, organism, study_type, technology, release-date range, extra facets) combine with AND.

Field	Type	Requirement and constraints
query	string	optional
organism	string	optional
study_type	string	optional
technology	string	optional
released_after	string	optional
released_before	string	optional
extra_facets	object	optional
max_records	integer	optional; default: 50

const result = await host.mcp("omics-archives", "arrayexpress_search_experiments", {"organism": "Homo sapiens", "study_type": "ChIP-seq", "max_records": 50})

arrayexpress_get_experiment

Fetch one ArrayExpress experiment (BioStudies) as a flattened analyst record — study type, organisms, assay/sample counts, designs/factors, authors, publications, protocols, array designs, and file summary.

Field	Type	Requirement and constraints
accession	string	required

const result = await host.mcp("omics-archives", "arrayexpress_get_experiment", {"accession": "E-MTAB-5061"})

arrayexpress_get_experiment_files

List every file of an ArrayExpress experiment (name, size, type, format, description) with download URLs, plus the /info endpoint file count carried alongside for comparison.

Field	Type	Requirement and constraints
accession	string	required

const result = await host.mcp("omics-archives", "arrayexpress_get_experiment_files", {"accession": "E-MTAB-5061"})

arrayexpress_get_experiment_samples

Fetch relationship rows from the first SDRF file sorted by path for an ArrayExpress experiment, preserving every sample/assay/file relationship in that file (trimmed MAGE-TAB headers, repeats suffixed #2/#3). Count distinct named sample/source identifiers, not independent biological replicates, using Sample Name in preference to Source Name. Experiments with no SDRF return {"error":"no_sdrf"}.

Field	Type	Requirement and constraints
accession	string	required
max_rows_returned	integer	optional; default: 200

const result = await host.mcp("omics-archives", "arrayexpress_get_experiment_samples", {"accession": "E-MTAB-5061", "max_rows_returned": 200})

geo_search_series

Search NCBI GEO DataSets (db=gds) and return series-level records (trimmed esummary docs). term is full E-utilities syntax; add gse[ETYP] to restrict to series.

Field	Type	Requirement and constraints
term	string	required
retmax	integer	optional; default: 500

const result = await host.mcp("omics-archives", "geo_search_series", {"term": "asthma AND gse[ETYP]", "retmax": 20})

geo_get_series

Fetch structured metadata for GEO series (GSE accessions) with samples included — series title/summary/design, platforms, samples with characteristics and library info, and supplementary-file URLs. Data tables are never downloaded. Use geo_get_matrix_files next to discover Series Matrix and NCBI-generated RNA-seq count files, then geo_preflight_matrix to check decompressed data against these samples.

Field	Type	Requirement and constraints
accessions	array of string	required

const result = await host.mcp("omics-archives", "geo_get_series", {"accessions": ["GSE131907"]})

metabolights_list_studies

List every public MetaboLights study accession (numerically sorted) with the API's own reported count. There is no server-side study search — filter fetched candidates by title/descriptor instead.

Field	Type	Requirement and constraints
—	object	No fields; pass an empty object.

const result = await host.mcp("omics-archives", "metabolights_list_studies", {})

metabolights_get_studies

Fetch structured metadata for MetaboLights studies (MTBLSxxx) from the parsed ISA payload — title, status, years, organisms, assays, factors, descriptors, sample count, protocols; optional per-sample table with unique column keys preserving ISA column order and associations. Unknown/private accessions go in not_found.

Field	Type	Requirement and constraints
accessions	array of string	required
include_samples	boolean	optional; default: false
max_sample_rows_returned	integer	optional; default: 200

const result = await host.mcp("omics-archives", "metabolights_get_studies", {"accessions": ["MTBLS1"], "include_samples": false})

metabolights_get_study_files

Complete file inventory for a public MetaboLights study — the top-level study folder (ISA-Tab, MAF, folder entries) and, by default, the recursive FILES data folder.

Field	Type	Requirement and constraints
accession	string	required
include_data_files	boolean	optional; default: true

const result = await host.mcp("omics-archives", "metabolights_get_study_files", {"accession": "MTBLS1"})

metabolights_search_data_files

Glob search over a MetaboLights study's raw-data folder (FILES tree). pattern is a filename glob (e.g. '.mzML', '.raw'); omit it to list every data file.

Field	Type	Requirement and constraints
accession	string	required
pattern	string	optional

const result = await host.mcp("omics-archives", "metabolights_search_data_files", {"accession": "MTBLS1", "pattern": "*.zip"})

mgnify_search_studies

Find MGnify metagenomics studies by free text OR biome lineage (provide exactly one). Full listing is paginated to completion and count-verified against the API.

Field	Type	Requirement and constraints
query	string	optional
biome_lineage	string	optional

const result = await host.mcp("omics-archives", "mgnify_search_studies", {"query": "coral"})

mgnify_get_studies

Fetch structured records for MGnify studies (MGYS accessions). With include_analyses, each study also carries its complete analyses listing plus by-pipeline/by-experiment breakdowns. Unknown accessions go in missing.

Field	Type	Requirement and constraints
accessions	array of string	required
include_analyses	boolean	optional; default: false

const result = await host.mcp("omics-archives", "mgnify_get_studies", {"accessions": ["MGYS00000410"], "include_analyses": false})

mgnify_get_study_analyses

List ALL analyses of one MGnify study (complete, count-verified pagination) — one record per MGYA analysis with pipeline version, experiment type, status, and run/assembly/sample accessions.

Field	Type	Requirement and constraints
accession	string	required

const result = await host.mcp("omics-archives", "mgnify_get_study_analyses", {"accession": "MGYS00000410"})

pride_get_project_files

List one page of public PRIDE project files for a PXD or PRD accession, including file category, byte size, upstream checksum and download locations (FTP, HTTP or Aspera). Metadata only: does not download files or verify checksums. Pages are zero-based; keep page_size unchanged and follow next_page until null. Ordering is supplied by PRIDE, not a snapshot. An empty list does not establish whether a project exists or is public.

Field	Type	Requirement and constraints
project_accession	string	required; maxLength: 32; pattern: "^(?:PXD|PRD)[0-9]{6,}$"
page	integer	optional; default: 0; minimum: 0; maximum: 1000000
page_size	integer	optional; default: 100; minimum: 1; maximum: 100

const result = await host.mcp("omics-archives", "pride_get_project_files", {"project_accession": "PXD000001", "page": 0, "page_size": 100})

pride_search_projects

Search PRIDE Archive proteomics projects (complete, api_total-verified retrieval); filters (keyword, organism, instrument, disease, extra_filters) combine with AND. Sorted by accession ASC — a bounded walk is a stable prefix.

Field	Type	Requirement and constraints
keyword	string	optional
organism	string	optional
instrument	string	optional
disease	string	optional
extra_filters	object	optional
max_records_returned	integer	optional; default: 50

const result = await host.mcp("omics-archives", "pride_search_projects", {"keyword": "phosphoproteome", "organism": "Homo sapiens (human)", "max_records_returned": 50})

pride_get_projects

Fetch full metadata for PRIDE projects by accession (e.g. PXD010154) — the same normalized record shape as pride_search_projects, so the two are directly comparable. Unknown accessions go in not_found.

Field	Type	Requirement and constraints
accessions	array of string	required

const result = await host.mcp("omics-archives", "pride_get_projects", {"accessions": ["PXD010154"]})

pride_search_project_proteins

List protein evidence rows for one PRIDE affinity-proteomics project (paged to exhaustion). NOTE: only affinity-proteomics projects are served here; for classic MS (PXD) projects use pride_find_projects_for_protein instead.

Field	Type	Requirement and constraints
project_accession	string	required
keyword	string	optional

const result = await host.mcp("omics-archives", "pride_search_project_proteins", {"project_accession": "PXD010154"})

pride_find_projects_for_protein

Find PRIDE projects containing a protein (MS-archive direction). protein_accession is a UniProt accession (e.g. P04637). Feed the returned project accessions to pride_get_projects for full metadata.

Field	Type	Requirement and constraints
protein_accession	string	required

const result = await host.mcp("omics-archives", "pride_find_projects_for_protein", {"protein_accession": "P04637"})

mgnify_get_analysis_files

List result-file metadata for one MGnify analysis using API v2: file type, category, byte size when reported, and upstream download URL. No file bytes are downloaded. Missing sizes or URLs remain null.

Field	Type	Requirement and constraints
accession	string	required; maxLength: 32; pattern: "^MGYA[0-9]{8,}$"

const result = await host.mcp("omics-archives", "mgnify_get_analysis_files", {"accession": "MGYA00639970"})

workbench_search_compounds

Look up Metabolomics Workbench compounds by registry number, formula, InChIKey, or a PubChem, HMDB, KEGG, ChEBI, LIPID MAPS or MetaCyc cross-reference. Returns available SMILES, structure identifiers, formula, exact mass and cross-references. Compound names are not a supported input; resolve names with PubChem first.

Field	Type	Requirement and constraints
field	string	required; enum: ["regno", "formula", "inchi_key", "lm_id", "pubchem_cid", "hmdb_id", "kegg_id", "chebi_id", "metacyc_id"]
query	string	required; minLength: 1; maxLength: 200
limit	integer	optional; default: 100; minimum: 1; maximum: 1000

const result = await host.mcp("omics-archives", "workbench_search_compounds", {"field": "pubchem_cid", "query": "5793"})

workbench_search_studies

Search public Metabolomics Workbench study summaries by a title substring or institute. Returns study IDs and available species, sample counts, analysis types and license metadata. Use workbench_get_study for a selected study’s samples, experimental factors, analyses or metabolite annotations.

Field	Type	Requirement and constraints
field	string	optional; default: "study_title"; enum: ["study_title", "institute"]
query	string	required; minLength: 1; maxLength: 200
limit	integer	optional; default: 100; minimum: 1; maximum: 1000

const result = await host.mcp("omics-archives", "workbench_search_studies", {"query": "Diabetes", "limit": 20})

workbench_get_study

Retrieve one public Metabolomics Workbench study (ST followed by six digits). Select summary for the study record; factors for samples, sample sources and experimental variables; analysis for instrument and experimental metadata; metabolites for measured metabolite annotations and cross-references. Preserves upstream fields and factor text. Does not download raw files or measurement matrices.

Field	Type	Requirement and constraints
study_id	string	required; pattern: "^ST[0-9]{6}$"
section	string	optional; default: "summary"; enum: ["summary", "factors", "analysis", "metabolites"]
limit	integer	optional; default: 100; minimum: 1; maximum: 1000

const result = await host.mcp("omics-archives", "workbench_get_study", {"study_id": "ST000001", "section": "factors"})

geo_get_matrix_files

Discover Series Matrix files and NCBI-generated RNA-seq raw counts, FPKM/TPM and gene annotation files for one GSE from live NCBI listings. Returns advertised URLs, not downloaded matrices or verified file contents. Start with geo_get_series for sample metadata. Offer the official URL for manual download by the user, then use geo_preflight_matrix on locally read decompressed text. Do not bypass host.mcp with raw HTTP. Missing or failed listings do not prove absence of data; also inspect the series supplementary files.

Field	Type	Requirement and constraints
accession	string	required; pattern: "^GSE[1-9][0-9]*$"

const result = await host.mcp("omics-archives", "geo_get_matrix_files", {"accession":"GSE164073"})

geo_preflight_matrix

Preflight decompressed dense TSV or Series Matrix text (up to 8 MiB) without network or filesystem access. Supply samples from geo_get_series (accession, title, platform_id) to map columns by GSM, never by position. Only plain TSV supports unique exact title matching; GSM-shaped columns never fall back to titles. Series Matrix requires exactly one !Sample_geo_accession header containing valid GSM accessions matching the sample column count and order, and never falls back to title matching. For larger files use complete:false and perform full validation in the analysis environment. For plain TSV previews, pass the table header plus complete preview rows. For Series Matrix previews, also preserve the preceding metadata, including !Sample_geo_accession and any !Sample_platform_id header, and !series_matrix_table_begin; do not submit only the table or fabricate !series_matrix_table_end. Set complete:true only when text contains the entire file. For plain TSV, completeness is caller-declared, not independently verified. A preview cannot establish total dimensions. Does not handle sparse Matrix Market, archives, HDF5 or multiline TSV fields. Preserve sample_mapping column order when preparing the analysis matrix.

Field	Type	Requirement and constraints
text	string	required; minLength: 1; maxLength: 8388608
complete	boolean	optional; default: false
matrix_kind	string	optional; default: "unknown"; enum: ["series_matrix", "raw_counts", "normalized_counts", "unknown"]
samples	array of object	optional; maxItems: 10000

const result = await host.mcp("omics-archives", "geo_preflight_matrix", {"text":"GeneID\tGSM5000001\n1\t12\n","complete":false,"matrix_kind":"raw_counts","samples":[{"accession":"GSM5000001"}]})

CellGuide

Show operations and parameters

get_cell_type_info

CellGuide (CELLxGENE) cell-type info by Cell Ontology id or name: name, synonyms, ontology description, and curated/GPT description.

Field	Type	Requirement and constraints
cell_type	string	required

const result = await host.mcp("cellguide", "get_cell_type_info", {"cell_type": "acinar cell"})

search_cell_types

Search CellGuide cell types by free text over name and synonyms (the CDN has no search endpoint, so celltype_metadata.json is filtered client-side).

Field	Type	Requirement and constraints
query	string	required
limit	integer	optional; default: 25

const result = await host.mcp("cellguide", "search_cell_types", {"query": "T cell", "limit": 25})

get_marker_genes

CellGuide marker genes for a cell type (id or name): computational (data-derived, scored) or canonical (literature-curated).

Field	Type	Requirement and constraints
cell_type	string	required
marker_type	string	optional; default: "computational"; enum: ["computational", "canonical"]
limit	integer	optional; default: 25

const result = await host.mcp("cellguide", "get_marker_genes", {"cell_type": "CL:0000084", "marker_type": "computational", "limit": 25})

get_source_data

CellGuide source datasets and publications contributing to a cell type (id or name): collection name/url, publication, and the tissues/diseases/organisms each covers.

Field	Type	Requirement and constraints
cell_type	string	required

const result = await host.mcp("cellguide", "get_source_data", {"cell_type": "CL:0000622"})

get_cell_tissues

Anatomical tissues where a cell type (id or name) is observed, aggregated (deduplicated) across CellGuide source collections.

Field	Type	Requirement and constraints
cell_type	string	required

const result = await host.mcp("cellguide", "get_cell_tissues", {"cell_type": "T cell"})

Regulation

Show operations and parameters

encode_search_experiments

Search ENCODE functional-genomics experiments (ChIP-seq, ATAC-seq, ...). Filters: assay_title (e.g. "TF ChIP-seq"), target (protein label, e.g. "CTCF"), organism (scientific name), status (default "released"), date_released_before (ISO date — a closed window), plus arbitrary portal field filters via extra_filters. The full result set is paged and count-verified; accessions lists every match, at most max_rows row summaries are returned.

Field	Type	Requirement and constraints
assay_title	string	optional
target	string	optional
organism	string	optional
status	string	optional; default: "released"
date_released_before	string	optional
extra_filters	object	optional
max_rows	integer	optional; default: 100

const result = await host.mcp("regulation", "encode_search_experiments", {"target": "CTCF", "assay_title": "TF ChIP-seq", "max_rows": 50})

encode_search_biosamples

Search ENCODE biosamples (cell lines, tissues, primary cells). Filters: term_name (ontology term, e.g. "K562"), classification ("cell line", "tissue", ...), organism (scientific name), status (default "released"), date_created_before (ISO date), plus arbitrary portal field filters via extra_filters. Complete, count-verified: accessions is the full match list, at most max_rows row summaries are returned.

Field	Type	Requirement and constraints
term_name	string	optional
classification	string	optional
organism	string	optional
status	string	optional; default: "released"
date_created_before	string	optional
extra_filters	object	optional
max_rows	integer	optional; default: 100

const result = await host.mcp("regulation", "encode_search_biosamples", {"term_name": "K562", "classification": "cell line", "max_rows": 25})

encode_list_files

List ENCODE data files by format / assay / biosample. Filters: file_format ("fastq", "bam", "bigWig", "bed", ...), assay_term_name (the ontology term e.g. "ChIP-seq" — NOT the display assay_title like "TF ChIP-seq", which matches nothing; pass titles via extra_filters={"assay_title": ...}), biosample_term_name (e.g. "K562"), status (default "released"), date_created_before, plus arbitrary portal field filters via extra_filters. File queries match millions of rows unfiltered — always combine several filters. Complete + count-verified; at most max_rows row summaries returned.

Field	Type	Requirement and constraints
file_format	string	optional
assay_term_name	string	optional
biosample_term_name	string	optional
status	string	optional; default: "released"
date_created_before	string	optional
extra_filters	object	optional
max_rows	integer	optional; default: 100

const result = await host.mcp("regulation", "encode_list_files", {"file_format": "bed", "assay_term_name": "ChIP-seq", "biosample_term_name": "K562", "extra_filters": {"output_type": "peaks", "assembly": "GRCh38"}, "max_rows": 50})

encode_get_experiment

Get one ENCODE experiment by accession (e.g. "ENCSR000AKP"). Returns a stable-field record: assay, target, biosample ontology + summary, description, lab, award project, release/submission dates, assemblies, replicate counts, replication type, dbxrefs, DOI and uuid. Volatile portal fields (audits, analyses, internal status) are excluded.

Field	Type	Requirement and constraints
accession	string	required

const result = await host.mcp("regulation", "encode_get_experiment", {"accession": "ENCSR000AKP"})

encode_get_file

Get one ENCODE file by accession (e.g. "ENCFF002JUR"). Returns a stable-field record: format, output type/category, assay, assembly, parent dataset, biological replicates, file size, md5sums, run type, read length, lab, creation date, download href and uuid.

Field	Type	Requirement and constraints
accession	string	required

const result = await host.mcp("regulation", "encode_get_file", {"accession": "ENCFF002JUR"})

encode_get_biosample

Get one ENCODE biosample by accession (e.g. "ENCBS013JZP"). Returns a stable-field record: ontology term + classification, organism, summary/description, source, donor, treatments, genetic modifications, life stage, age, sex, lab, creation date, status and uuid.

Field	Type	Requirement and constraints
accession	string	required

const result = await host.mcp("regulation", "encode_get_biosample", {"accession": "ENCBS013JZP"})

jaspar_get_matrix

Get one JASPAR TF binding profile by VERSIONED matrix id (e.g. "MA0002.2"). Returns the full record: position frequency matrix (pfm), TF name/class/family, species, data type, literature references (pubmed/medline), sequence logo URL. Requires a versioned id ("MA0002.2", not "MA0002") — use jaspar_matrix_versions to enumerate versions. Versioned matrices are immutable, so results are reproducible.

Field	Type	Requirement and constraints
matrix_id	string	required

const result = await host.mcp("regulation", "jaspar_get_matrix", {"matrix_id": "MA0002.2"})

jaspar_matrix_versions

List all versions of a JASPAR base matrix id (e.g. "MA0002"). Returns every released version with its matrix_id, name, collection and URL — count-verified. Use to pin an exact version before jaspar_get_matrix, or to track how a profile changed across releases. A versioned id ("MA0002.2") is accepted and reduced to its base.

Field	Type	Requirement and constraints
base_id	string	required

const result = await host.mcp("regulation", "jaspar_matrix_versions", {"base_id": "MA0002"})

jaspar_list_matrices

Search/list JASPAR TF binding profiles (the full profile catalog). Filters (all optional): collection ("CORE", "UNVALIDATED"), tax_group ("vertebrates", "plants", ...), tax_id (NCBI taxonomy id, e.g. 9606 for human — this is how you filter by species; enumerate ids with jaspar_list_species), name (exact TF name, e.g. "FOXA1"), search (free text), version="latest" (restrict to latest versions only). The full filtered catalog is paginated and count-verified; at most max_rows summary rows are returned.

Field	Type	Requirement and constraints
collection	string	optional
tax_group	string	optional
tax_id	integer	optional
name	string	optional
search	string	optional
version	string	optional
max_rows	integer	optional; default: 1000

const result = await host.mcp("regulation", "jaspar_list_matrices", {"tax_id": 9606, "collection": "CORE", "version": "latest", "max_rows": 200})

jaspar_list_species

List all species with JASPAR profiles (NCBI tax_id + name); count-verified full listing. Use the tax_id values to filter jaspar_list_matrices (e.g. 9606 = Homo sapiens, 10090 = Mus musculus).

Field	Type	Requirement and constraints
—	object	No fields; pass an empty object.

const result = await host.mcp("regulation", "jaspar_list_species", {})

jaspar_list_taxa

List all JASPAR taxonomic groups (vertebrates, plants, fungi, insects, ...); count-verified full listing. Use the group names as the tax_group filter of jaspar_list_matrices.

Field	Type	Requirement and constraints
—	object	No fields; pass an empty object.

const result = await host.mcp("regulation", "jaspar_list_taxa", {})

jaspar_list_collections

List all JASPAR collections (CORE, UNVALIDATED, ...); count-verified full listing. Use the collection names as the collection filter of jaspar_list_matrices (CORE = curated, non-redundant profiles).

Field	Type	Requirement and constraints
—	object	No fields; pass an empty object.

const result = await host.mcp("regulation", "jaspar_list_collections", {})

jaspar_list_releases

List all JASPAR database releases (year, release number, active flag); count-verified full listing. Record the active release when selecting motifs for reproducibility, or check release history before comparing results across JASPAR versions.

Field	Type	Requirement and constraints
—	object	No fields; pass an empty object.

const result = await host.mcp("regulation", "jaspar_list_releases", {})

unibind_search_tfbs

Search UniBind ChIP-seq datasets with high-confidence TFBS predictions (unibind.uio.no, 2021 release; direct TF-DNA interactions from ~10k datasets across 9 species). Each dataset is one (experiment, cell type, TF) triple. Filters (all optional, AND-combined, exact-match unless noted): tf_name (gene symbol, e.g. "CTCF"), cell_line (verbose UniBind title — prefer search for fuzzy matching), species (scientific name), collection ("Robust" = best-model / high confidence, or "Permissive"), jaspar_id (versioned, e.g. "MA0139.1"), search (free text). total is the API's exact count; at most max_rows rows are returned (a stable prefix).

Field	Type	Requirement and constraints
tf_name	string	optional
cell_line	string	optional
species	string	optional
collection	string	optional; enum: ["Robust", "Permissive"]
jaspar_id	string	optional
search	string	optional
max_rows	integer	optional; default: 200

const result = await host.mcp("regulation", "unibind_search_tfbs", {"tf_name": "CTCF", "collection": "Robust", "max_rows": 50})

unibind_get_dataset

Get one UniBind dataset's detail: per-model TFBS counts + file URLs. tf_id is the dataset key "<identifier>.<cell_line>.<TF>" as returned by unibind_search_tfbs (e.g. "ENCSR000AUE.A549_lung_carcinoma.CTCF"). Returns the TF name, source identifiers (ENCODE/GEO/GTRD), cell lines, biological conditions, JASPAR matrix ids, ChIP-seq peak count, and one row per TFBS prediction model (DAMO/PWM/...) with total_tfbs, score/distance thresholds, adjusted CentriMo p-value, and direct BED/FASTA download URLs — use those URLs (not an MCP call) to retrieve the complete site list.

Field	Type	Requirement and constraints
tf_id	string	required

const result = await host.mcp("regulation", "unibind_get_dataset", {"tf_id": "ENCSR000AUE.A549_lung_carcinoma.CTCF"})

unibind_tfbs_in_region

TF binding sites overlapping a genomic region (UniBind 2021 maps), served via the UCSC hubApi against UniBind's registered public track hubs (UniBind's own REST API has no region endpoint). Coordinates are 0-based half-open. genome: UCSC assembly — Robust hub: hg38, mm10, ce11, dm6, danRer11, sacCer3, rn6, araTha1; Permissive adds spo2 (no hg19 — lift first). chrom: with "chr" prefix. start/end: interval, end-start <= 1,000,000 bp. HONEST-CAP: at most 20,000 items are scanned per call; region_scan_complete=false means the region has more sites than were scanned (narrow the window) and, with tf_name set, matches may be missing. n_matching counts scanned sites passing the filter; returned/truncated describe the max_sites cap.

Field	Type	Requirement and constraints
genome	string	required
chrom	string	required
start	integer	required
end	integer	required
tf_name	string	optional
collection	string	optional; default: "Robust"; enum: ["Robust", "Permissive"]
max_sites	integer	optional; default: 2000

const result = await host.mcp("regulation", "unibind_tfbs_in_region", {"genome": "hg38", "chrom": "chr1", "start": 1000000, "end": 1010000, "collection": "Robust"})

Research Resources

Show operations and parameters

search_grants

Search Grants.gov funding opportunities via the search2 API (complete, count-verified retrieval). At least one criterion is required (keyword, opportunity_number, aln/CFDA, agencies, eligibilities, funding_categories, or funding_instruments). opportunity_statuses defaults to ["forecasted","posted"] (current opportunities); add "closed"/"archived" for historical ones. agencies takes codes like ["HHS-NIH11"] (NIH), ["HHS-FDA"], ["NSF"]. Set count_only for just the hit count + facets; max_records caps returned records (the walk still retrieves the complete set and flags truncated).

Field	Type	Requirement and constraints
keyword	string	optional
opportunity_number	string	optional
aln	string	optional
agencies	array of string	optional
opportunity_statuses	array of string	optional
eligibilities	array of string	optional
funding_categories	array of string	optional
funding_instruments	array of string	optional
count_only	boolean	optional; default: false
max_records	integer	optional; default: 100
include_facets	boolean	optional; default: true

const result = await host.mcp("research-resources", "search_grants", {"keyword": "cancer", "agencies": ["HHS-NIH11"], "max_records": 25})

search_antibodies

Full-text search the Antibody Registry (antibodyregistry.org, ~3.2M records). Token-based matching against antibody name/target/catalog text ("TP53" and "p53" are different queries). With page omitted, all pages are walked up to max_records or the anonymous depth cap (rows beyond offset 500 need authentication upstream, flagged as anonymous_limit_hit — never silently dropped). Pass a 1-based page for single-page retrieval (page*page_size must stay <= 500).

Field	Type	Requirement and constraints
query	string	required
page	integer	optional
page_size	integer	optional; default: 100
max_records	integer	optional; default: 500

const result = await host.mcp("research-resources", "search_antibodies", {"query": "CD4", "max_records": 100})

get_antibody

Fetch Antibody Registry detail record(s) for one antibody accession / RRID. Accepts a plain number ("3643095"), "AB_3643095", or "RRID:AB_3643095". The upstream route is list-valued (an accession can map to several curated records, e.g. multi-vendor duplicates). A nonexistent id yields record_count 0, not an error.

Field	Type	Requirement and constraints
antibody_id	string	required

const result = await host.mcp("research-resources", "get_antibody", {"antibody_id": "RRID:AB_3643095"})

find_antibodies_by_catalog

Find antibodies by vendor catalog number (exact, case-insensitive). Implemented as a full-text search plus client-side exact matching on the catalog number (or its listed alternatives), because the upstream column-filter route returns HTTP 500 for every key. Pass an optional vendor name (exact, case-insensitive) to further narrow the matches.

Field	Type	Requirement and constraints
catalog_number	string	required
vendor	string	optional
page_size	integer	optional; default: 100

const result = await host.mcp("research-resources", "find_antibodies_by_catalog", {"catalog_number": "ab32572"})

get_antibody_registry_stats

Antibody Registry statistics: total antibody count and last-update date. Returns the upstream /api/datainfo payload.

Field	Type	Requirement and constraints
—	object	No fields; pass an empty object.

const result = await host.mcp("research-resources", "get_antibody_registry_stats", {})

BioMart

Show operations and parameters

list_marts

List available Ensembl BioMart marts (databases). BioMart organizes data as MART -> DATASET -> ATTRIBUTES/FILTERS; a mart name feeds list_datasets.

Field	Type	Requirement and constraints
—	object	No fields; pass an empty object.

const result = await host.mcp("biomart", "list_marts", {})

list_datasets

List the datasets available in a given mart (e.g. hsapiens_gene_ensembl for human genes). A dataset name feeds the attribute/filter/query tools.

Field	Type	Requirement and constraints
mart	string	required

const result = await host.mcp("biomart", "list_datasets", {"mart": "ENSEMBL_MART_ENSEMBL"})

list_common_attributes

List the commonly used attributes for a dataset (a curated high-signal subset). Use this before list_all_attributes to pick attributes for get_data. mart is accepted for signature parity but ignored; the query keys off dataset.

Field	Type	Requirement and constraints
mart	string	required
dataset	string	required

const result = await host.mcp("biomart", "list_common_attributes", {"mart": "ENSEMBL_MART_ENSEMBL", "dataset": "hsapiens_gene_ensembl"})

list_all_attributes

List all attributes available for a dataset, minus homologs and microarray probes (which are bulky and rarely needed). Can be large; prefer list_common_attributes first. mart is accepted for signature parity but ignored; the query keys off dataset.

Field	Type	Requirement and constraints
mart	string	required
dataset	string	required

const result = await host.mcp("biomart", "list_all_attributes", {"mart": "ENSEMBL_MART_ENSEMBL", "dataset": "hsapiens_gene_ensembl"})

list_filters

List the filters available for a dataset. Filters narrow a get_data query (e.g. chromosome_name, biotype) and are passed to get_data as a filters dict. mart is accepted for signature parity but ignored; the query keys off dataset.

Field	Type	Requirement and constraints
mart	string	required
dataset	string	required

const result = await host.mcp("biomart", "list_filters", {"mart": "ENSEMBL_MART_ENSEMBL", "dataset": "hsapiens_gene_ensembl"})

get_data

Run a BioMart query: retrieve the requested attributes for a dataset, optionally narrowed by filters. This is the main data-retrieval tool. mart is accepted for signature parity but ignored; the query keys off dataset.

Field	Type	Requirement and constraints
mart	string	required
dataset	string	required
attributes	array of string	required
filters	object	optional

const result = await host.mcp("biomart", "get_data", {"mart": "ENSEMBL_MART_ENSEMBL", "dataset": "hsapiens_gene_ensembl", "attributes": ["ensembl_gene_id", "external_gene_name", "chromosome_name"], "filters": {"chromosome_name": "Y", "biotype": "protein_coding"}})

get_translation

Translate a single identifier from one attribute type to another (e.g. an HGNC symbol to an Ensembl gene ID) within a dataset. mart is accepted for signature parity but ignored; the query keys off dataset.

Field	Type	Requirement and constraints
mart	string	required
dataset	string	required
from_attr	string	required
to_attr	string	required
target	string	required

const result = await host.mcp("biomart", "get_translation", {"mart": "ENSEMBL_MART_ENSEMBL", "dataset": "hsapiens_gene_ensembl", "from_attr": "hgnc_symbol", "to_attr": "ensembl_gene_id", "target": "TP53"})

batch_translate

Translate many identifiers from one attribute type to another in a single query — more efficient than repeated get_translation calls. mart is accepted for signature parity but ignored; the query keys off dataset.

Field	Type	Requirement and constraints
mart	string	required
dataset	string	required
from_attr	string	required
to_attr	string	required
targets	array of string	required

const result = await host.mcp("biomart", "batch_translate", {"mart": "ENSEMBL_MART_ENSEMBL", "dataset": "hsapiens_gene_ensembl", "from_attr": "hgnc_symbol", "to_attr": "ensembl_gene_id", "targets": ["TP53", "BRCA1", "BRCA2"]})

ZINC

Show operations and parameters

zinc_search_by_id

Look up purchasable compounds in ZINC22/ZINC20 by ZINC identifier — answers "what is this compound and who sells it". Batched: pass up to 100 ids in one call rather than many single-id calls. Async upstream (submit + poll); can take up to timeout_s seconds.

Field	Type	Requirement and constraints
zinc_ids	['string', 'array']	required
max_results	integer	optional; default: 50
timeout_s	number	optional; default: 25

const result = await host.mcp("zinc", "zinc_search_by_id", {"zinc_ids": ["ZINC000000000012"]})

zinc_search_by_smiles

Search ZINC22's purchasable chemical space by structure — answers "what purchasable compounds look like this SMILES". This is BOTH the exact-match and the analog-discovery (similarity) tool: CartBlanche22 exposes one structure-search endpoint whose dist parameter spans exact through diverse, so there is deliberately no separate similarity-search tool. The slowest ZINC query — raise dist gradually rather than starting loose.

Field	Type	Requirement and constraints
smiles	string	required
dist	integer	optional; default: 0
adist	integer	optional
max_results	integer	optional; default: 50
timeout_s	number	optional; default: 25

const result = await host.mcp("zinc", "zinc_search_by_smiles", {"smiles": "CC(=O)Oc1ccccc1C(=O)O", "dist": 2})

zinc_search_by_supplier

Resolve vendor catalog numbers to ZINC compounds — answers "which ZINC substance is this supplier code, and what's its structure". Batched: up to 100 supplier codes per call. Async upstream (submit + poll).

Field	Type	Requirement and constraints
supplier_codes	['string', 'array']	required
max_results	integer	optional; default: 50
timeout_s	number	optional; default: 25

const result = await host.mcp("zinc", "zinc_search_by_supplier", {"supplier_codes": ["MCULE-2311834287"]})

zinc_random_sample

Draw a random sample of purchasable compounds from ZINC22 — for building screening decks, property baselines, or decoy sets. count doubles as this tool's max_results; re-calling draws a fresh sample. Async upstream (submit + poll).

Field	Type	Requirement and constraints
count	integer	optional; default: 50
subset	string	optional
timeout_s	number	optional; default: 25

const result = await host.mcp("zinc", "zinc_random_sample", {"count": 25, "subset": "lead-like"})

zinc_get_3d

Locate docking-ready 3D structures for ZINC compounds. ZINC22 ships pre-generated 3D conformers (DOCK .db2.gz, .mol2.gz, .sdf.gz) in its file repository, organized by tranche — this tool resolves each id to its tranche and returns the repository locations to download from for docking prep (DOCK6, AutoDock Vina, etc.). Max 50 ids per call (3D retrieval is per-compound work). Async upstream (submit + poll).

Field	Type	Requirement and constraints
zinc_ids	['string', 'array']	required
timeout_s	number	optional; default: 25

const result = await host.mcp("zinc", "zinc_get_3d", {"zinc_ids": ["ZINC000000000012"]})

Example response records

The example response records include exact inputs, capped response excerpts and per-operation outcomes. Distinguish a returned record, an empty match and a failed request. Results may be metadata, schemas or identifiers; check the source fields and completeness flags before using them in your research.

GDC

Show operations and parameters

gdc_list_projects

List GDC cancer projects and their case/file summaries. Filters are explicit and bounded; this is metadata discovery, not a data download operation.

Field	Type	Requirement and constraints
project_ids	string / array	optional
disease_type	string	optional; minLength: 1; maxLength: 200
primary_site	string	optional; minLength: 1; maxLength: 200
page	integer	optional; default: 1; minimum: 1; maximum: 10000
page_size	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("gdc", "gdc_list_projects", {"project_ids": "TCGA-BRCA", "page_size": 5})

gdc_list_cases

List GDC cases (sample donors) with project, disease and biospecimen metadata (samples and aliquots). Results identify cases and do not expose or download controlled data.

Field	Type	Requirement and constraints
project_ids	string / array	optional
submitter_ids	string / array	optional
case_ids	string / array	optional
page	integer	optional; default: 1; minimum: 1; maximum: 10000
page_size	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("gdc", "gdc_list_cases", {"project_ids": ["TCGA-BRCA"], "page_size": 5})

gdc_search_files

Search the GDC file inventory by project, case UUID, sample type and analysis workflow type (OR within each filter, AND across filters), and explicitly label each file as open or controlled access. Metadata discovery does not grant download access; controlled files require appropriate GDC authorization.

Field	Type	Requirement and constraints
project_ids	string / array	optional
case_ids	string / array	optional
sample_types	string / array	optional
workflow_types	string / array	optional
access	string	optional; default: "all"; enum: ["all", "open", "controlled"]
data_category	string	optional; minLength: 1; maxLength: 200
data_type	string	optional; minLength: 1; maxLength: 200
data_format	string	optional; minLength: 1; maxLength: 50
file_name	string	optional; minLength: 1; maxLength: 500
page	integer	optional; default: 1; minimum: 1; maximum: 10000
page_size	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("gdc", "gdc_search_files", {"project_ids": ["TCGA-BRCA"], "sample_types": "Primary Tumor", "workflow_types": "STAR - Counts", "access": "open", "page_size": 10})

gdc_get_file

Retrieve metadata for one GDC file UUID, including its open/controlled access classification. This performs no file download and does not claim that a listed file is downloadable for the current user.

Field	Type	Requirement and constraints
file_id	string	required; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$"

const result = await host.mcp("gdc", "gdc_get_file", {"file_id": "cb92f61d-041c-4424-a3e9-891b7545f351"})

gdc_get_manifest

Create a GDC Data Transfer Tool manifest for up to 100 file UUIDs. The returned manifest is an inventory only; it does not download files or bypass controlled-access authorization.

Field	Type	Requirement and constraints
file_ids	array of string	required; minItems: 1; maxItems: 100; uniqueItems: true

const result = await host.mcp("gdc", "gdc_get_manifest", {"file_ids": ["cb92f61d-041c-4424-a3e9-891b7545f351"]})

Zenodo

Show operations and parameters

search_records

Search public Zenodo records (datasets, software and publications) using Zenodo query-string syntax, e.g. title:"climate" or doi:"10.5281/zenodo.8435696". Fetches one page, up to 25 records, without authentication. By default only the latest version is listed; all_versions includes older versions. For the next page, keep query, page_size, sort and all_versions unchanged. The search window is limited to 10,000 results: (page - 1) * page_size must be less than 10,000; the final page may be partial. If pagination_limited is true, narrow the query. Public metadata does not imply open file access.

Field	Type	Requirement and constraints
query	string	required; minLength: 1; maxLength: 1000; pattern: "\S"
page	integer	optional; default: 1; minimum: 1; maximum: 10000
page_size	integer	optional; default: 10; minimum: 1; maximum: 25
sort	string	optional; default: "bestmatch"; enum: ["bestmatch", "mostrecent"]
all_versions	boolean	optional; default: false

const result = await host.mcp("zenodo", "search_records", {"query": "title:climate", "page_size": 5})

get_record

Retrieve public Zenodo metadata and the file inventory exposed by the record endpoint. Pass a decimal record ID, not a DOI or URL. A concept ID may resolve to its latest version; requested_record_id, record_id and concept_record_id remain distinct. Use the returned version-specific record_id for reproducible lookup. description_html is upstream HTML, not sanitized. File links and checksums are metadata only: no download, checksum verification or access probe is performed. Restricted or embargoed records can have public metadata without accessible files; an empty file list does not establish that the deposit has no files.

Field	Type	Requirement and constraints
record_id	string	required; maxLength: 20; pattern: "^[1-9][0-9]*$"

const result = await host.mcp("zenodo", "get_record", {"record_id": "8435696"})

HMMER

Show operations and parameters

search

Submit one asynchronous EMBL-EBI HMMER3 search. program selects phmmer (protein sequence against a sequence database), hmmscan (protein sequence against Pfam profiles), hmmsearch (profile HMM/alignment against a sequence database), or jackhmmer (iterative remote-homolog search). input is the FASTA sequence, profile HMM, or alignment text accepted by that program. database is the provider database name. Optional thresholds use HMMER parameter names (incE/incdomE, E/domE, incT/incdomT, T/domT); iterations controls jackhmmer rounds. Submission is not completion: retain the returned job_id and poll with status. The service may accept a job even if the response is lost; never automatically resubmit an uncertain submission.

Field	Type	Requirement and constraints
program	string	required; enum: ["phmmer", "hmmscan", "hmmsearch", "jackhmmer"]
database	string	required; enum: ["refprot", "uniprot", "swissprot", "pdb", "rp15", "rp35", "rp55", "rp75", "pfam"]
input	string	required; minLength: 1; maxLength: 200000
incE	number	optional; exclusiveMinimum: 0; maximum: 10
incdomE	number	optional; exclusiveMinimum: 0; maximum: 10
incT	number	optional; exclusiveMinimum: 0
incdomT	number	optional; exclusiveMinimum: 0
E	number	optional; exclusiveMinimum: 0; maximum: 10
domE	number	optional; exclusiveMinimum: 0; maximum: 10
T	number	optional; exclusiveMinimum: 0
domT	number	optional; exclusiveMinimum: 0
popen	number	optional; minimum: 0
pextend	number	optional; minimum: 0
mx	string	optional; enum: ["BLOSUM45", "BLOSUM62", "BLOSUM90", "PAM30", "PAM70"]
iterations	integer	optional; minimum: 1; maximum: 9

const result = await host.mcp("hmmer", "search", {"program":"hmmscan","database":"pfam","input":">query\nMKTIIALSYIFCLVFADYKDDDDK"})

status

Check one HMMER job once, without polling or resubmitting. SUCCESS means results are available; PENDING/RUNNING means wait before checking again; ERROR/FAILURE/NOT_FOUND are terminal outcomes and never mean zero hits. Keep the exact job_id.

Field	Type	Requirement and constraints
job_id	string	required; maxLength: 36; pattern: "^[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}$"

const result = await host.mcp("hmmer", "status", {"job_id":"8ebb1d5f-4457-4da8-808c-f811105c3654"})

results

Retrieve one HMMER job result once. Checks the provider status first and returns no result payload while the job is pending or failed. On SUCCESS, retrieves all result pages, including domain annotations; jackhmmer iteration records are returned in the provider array shape. Preserve the result in a Notebook artifact because provider retention is finite; an empty match list is a completed zero-hit result, distinct from a pending or failed job.

Field	Type	Requirement and constraints
job_id	string	required; maxLength: 36; pattern: "^[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}$"

const result = await host.mcp("hmmer", "results", {"job_id":"8ebb1d5f-4457-4da8-808c-f811105c3654"})

InterProScan

Show operations and parameters

status

Check one InterProScan job once, without retrying or polling. Wait at least 10 seconds between checks. FINISHED means results can be retrieved; ERROR/FAILURE are job failures, NOT_FOUND means unknown or expired, never a zero-hit result. Keep the exact job_id; this tool never resubmits.

Field	Type	Requirement and constraints
job_id	string	required; maxLength: 200; pattern: "^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$"

const result = await host.mcp("interproscan", "status", {"job_id":"iprscan5-R20260922-123456-0123-12345678-p1m"})

results

Retrieve the complete InterProScan TSV report for a job, capped at 2 MiB (oversized reports fail, never truncate). Checks status once first, then fetches TSV only for FINISHED. No retries, polling, or resubmission. Preserve the report in a Notebook artifact promptly because provider results expire. TSV contains one row per signature match; coordinates are 1-based inclusive and scores are application-specific. Optional columns hold InterPro, GO and pathway annotations. An empty TSV after FINISHED means no reported matches, not evidence that the protein lacks function.

Field	Type	Requirement and constraints
job_id	string	required; maxLength: 200; pattern: "^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$"

const result = await host.mcp("interproscan", "results", {"job_id":"iprscan5-R20260922-123456-0123-12345678-p1m"})

submit

Submit one or more protein sequences to EMBL-EBI InterProScan for asynchronous domain and family annotation. Accepts raw protein sequence or FASTA input with at most 1,000 records, a local limit of 10,000 residues per record and a 4 MiB encoded request body limit. Returns a job_id immediately and never polls. Keep the job_id, then call status and results yourself after waiting at least 10 seconds between status checks. A lost response may represent an accepted job; do not resubmit automatically. A valid contact email is required. Set a contact email in Settings → Credentials → Literature access. This email is sent to EMBL-EBI when submitting a job. Keep the exact job_id to resume after restart. This connector adds no job registry, result cache or background polling. Cancellation, app exit and uninstall stop local requests only; this connector cannot cancel or delete remote jobs. Result expiry is controlled by EMBL-EBI. Sequences and contact email are sent to EMBL-EBI; tool inputs and outputs may be retained in conversation or Notebook persistence. Submit no more than 30 jobs in a batch and wait for processing/results before submitting more; cross-call throttling is not enforced. The existing results tool returns at most 2 MiB of TSV and rejects larger reports.

Field	Type	Requirement and constraints
sequence	string	required; minLength: 1; maxLength: 4194304
title	string	optional; minLength: 1; maxLength: 200

const result = await host.mcp("interproscan", "submit", {"sequence":">query\nMKTIIALSYIFCLVFADYKDDDDK"})

Pathway Commons

Show operations and parameters

pathway_commons_search

Search the Pathway Commons BioPAX model by gene/protein/pathway keyword or Lucene query. Results include BioPAX class, URI, source databases, organism, and pathway metadata. Use the returned URI as input to graph or export queries.

Field	Type	Requirement and constraints
q	string	required; minLength: 1; maxLength: 512
type	string	optional; minLength: 1; maxLength: 64
organism	array of string	optional; maxItems: 20
datasource	array of string	optional; maxItems: 20
page	integer	optional; default: 0; minimum: 0; maximum: 10000

const result = await host.mcp("pathway-commons", "pathway_commons_search", {"q": "TP53", "type": "ProteinReference", "organism": ["9606"]})

pathway_commons_top_pathways

Find top-level pathways in Pathway Commons matching a keyword or Lucene query, optionally restricted to a species or source such as Reactome.

Field	Type	Requirement and constraints
q	string	required; minLength: 1; maxLength: 512
organism	array of string	optional; maxItems: 20
datasource	array of string	optional; maxItems: 20

const result = await host.mcp("pathway-commons", "pathway_commons_top_pathways", {"q": "insulin", "datasource": ["reactome"], "organism": ["9606"]})

pathway_commons_graph

Run a Pathway Commons BioPAX graph query for a gene neighborhood, paths between gene sets, directed paths from sources to targets, or a common upstream/downstream stream. SIF results are normalized as interaction records, TXT results include edge and node records, and GSEA/BioPAX/SBGN exports remain available as text.

Field	Type	Requirement and constraints
source	array of string	required; minItems: 1; maxItems: 100
target	array of string	optional; minItems: 1; maxItems: 100
kind	string	optional; default: "NEIGHBORHOOD"; enum: ["NEIGHBORHOOD", "PATHSBETWEEN", "PATHSFROMTO", "COMMONSTREAM"]
format	string	optional; default: "SIF"; enum: ["BIOPAX", "SIF", "TXT", "GSEA", "SBGN", "JSONLD"]
limit	integer	optional; default: 1; minimum: 1; maximum: 10
direction	string	optional; enum: ["UPSTREAM", "DOWNSTREAM", "BOTHSTREAM", "UNDIRECTED"]
limit_type	string	optional; default: "NORMAL"; enum: ["NORMAL", "SHORTEST_PLUS_K"]
pattern	array of string	optional; maxItems: 14
organism	array of string	optional; maxItems: 20
datasource	array of string	optional; maxItems: 20
subpathways	boolean	optional; default: false

const result = await host.mcp("pathway-commons", "pathway_commons_graph", {"kind": "NEIGHBORHOOD", "source": ["TP53"], "format": "SIF", "pattern": ["INTERACTS_WITH"]})

pathway_commons_export

Fetch a BioPAX sub-model for one or more Pathway Commons IDs/URIs and export it as BioPAX, GSEA GMT, JSON-LD, SIF, TXT, or SBGN. Use a URI returned by search/top_pathways for precise pathway export.

Field	Type	Requirement and constraints
uri	array of string	required; minItems: 1; maxItems: 100
format	string	optional; default: "BIOPAX"; enum: ["BIOPAX", "SIF", "TXT", "GSEA", "SBGN", "JSONLD"]
pattern	array of string	optional; maxItems: 14
subpathways	boolean	optional; default: false

const result = await host.mcp("pathway-commons", "pathway_commons_export", {"uri": ["R-HSA-201451"], "format": "GSEA"})

Alliance Genome Resources

Show operations and parameters

alliance_get_gene

Retrieve a model-organism or human gene summary from the Alliance of Genome Resources, including symbol, species, synopsis, genomic location and cross-references.

Field	Type	Requirement and constraints
gene_id	string	required; minLength: 1; maxLength: 200

const result = await host.mcp("alliance", "alliance_get_gene", {"gene_id": "MGI:97490"})

alliance_search_genes

Search Alliance genes across human and model-organism databases by symbol, name or identifier.

Field	Type	Requirement and constraints
query	string	required; minLength: 1; maxLength: 200
limit	integer	optional; default: 20; minimum: 1; maximum: 100
page	integer	optional; default: 1; minimum: 1; maximum: 10000

const result = await host.mcp("alliance", "alliance_search_genes", {"query": "pax6", "limit": 10})

alliance_get_gene_orthologs

Retrieve cross-species orthologs for an Alliance gene, with orthology stringency and prediction methods.

Field	Type	Requirement and constraints
gene_id	string	required; minLength: 1; maxLength: 200
stringency	string	optional; default: "stringent"; enum: ["stringent", "moderate", "all"]
limit	integer	optional; default: 20; minimum: 1; maximum: 100
page	integer	optional; default: 1; minimum: 1; maximum: 10000

const result = await host.mcp("alliance", "alliance_get_gene_orthologs", {"gene_id": "HGNC:8620", "stringency": "stringent"})

alliance_get_gene_disease_models

Retrieve disease associations and model-organism disease models involving an Alliance gene.

Field	Type	Requirement and constraints
gene_id	string	required; minLength: 1; maxLength: 200
limit	integer	optional; default: 20; minimum: 1; maximum: 100
page	integer	optional; default: 1; minimum: 1; maximum: 10000

const result = await host.mcp("alliance", "alliance_get_gene_disease_models", {"gene_id": "MGI:97490"})

alliance_get_gene_phenotypes

Retrieve phenotype annotations for a gene across Alliance model organisms.

Field	Type	Requirement and constraints
gene_id	string	required; minLength: 1; maxLength: 200
limit	integer	optional; default: 20; minimum: 1; maximum: 100
page	integer	optional; default: 1; minimum: 1; maximum: 10000

const result = await host.mcp("alliance", "alliance_get_gene_phenotypes", {"gene_id": "HGNC:6081", "limit": 20})

alliance_get_gene_alleles

Retrieve alleles and variants associated with an Alliance gene, including disease and phenotype flags.

Field	Type	Requirement and constraints
gene_id	string	required; minLength: 1; maxLength: 200
limit	integer	optional; default: 20; minimum: 1; maximum: 100
page	integer	optional; default: 1; minimum: 1; maximum: 10000

const result = await host.mcp("alliance", "alliance_get_gene_alleles", {"gene_id": "MGI:97490"})

alliance_get_gene_expression

Retrieve expression annotations for an Alliance gene, including developmental stage, anatomical location, provider and evidence.

Field	Type	Requirement and constraints
gene_id	string	required; minLength: 1; maxLength: 200
limit	integer	optional; default: 20; minimum: 1; maximum: 100
page	integer	optional; default: 1; minimum: 1; maximum: 10000

const result = await host.mcp("alliance", "alliance_get_gene_expression", {"gene_id": "ZFIN:ZDB-GENE-990415-8"})

alliance_get_disease_genes

Retrieve genes associated with a Disease Ontology term across Alliance human and model-organism data.

Field	Type	Requirement and constraints
disease_id	string	required; minLength: 1; maxLength: 200
limit	integer	optional; default: 20; minimum: 1; maximum: 100
page	integer	optional; default: 1; minimum: 1; maximum: 10000

const result = await host.mcp("alliance", "alliance_get_disease_genes", {"disease_id": "DOID:162", "limit": 20})

CELLxGENE Discover

Show operations and parameters

list_collections

List public CELLxGENE Discover collections; optional case-insensitive substring query over name, description and DOI. Filtering and pagination are client-side over the complete API response, fetched on each call; results may change between calls. Save version IDs for reproducibility.

Field	Type	Requirement and constraints
query	string	optional; minLength: 1; maxLength: 500; pattern: "\S"
page	integer	optional; default: 1; minimum: 1; maximum: 1000000
page_size	integer	optional; default: 25; minimum: 1; maximum: 100

const result = await host.mcp("cellxgene-discover", "list_collections", {"query":"liver","page_size":10})

get_collection

Retrieve the latest public collection metadata by canonical collection_id, with a page of dataset summaries. Filtering and pagination are client-side over the complete API response, fetched on each call; results may change between calls. Save version IDs for reproducibility.

Field	Type	Requirement and constraints
collection_id	string	required; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
page	integer	optional; default: 1; minimum: 1; maximum: 1000000
page_size	integer	optional; default: 25; minimum: 1; maximum: 100

const result = await host.mcp("cellxgene-discover", "get_collection", {"collection_id":"9a71db9e-687f-41f0-b88e-544eb1314ef6"})

list_datasets

List public datasets. query matches title, collection name or DOI by case-insensitive substring. organism, tissue, disease, assay and cell_type match an exact ontology ID or label (case-insensitive); filters are ANDed. schema_version selects the latest published collection versions matching a major/minor/patch schema and can return historical datasets. Use each result's dataset_version_id with get_dataset_version or list_dataset_files to retain that publication; canonical IDs resolve to the current version. Filtering and pagination are client-side over the complete API response, fetched on each call; results may change between calls. Save version IDs for reproducibility.

Field	Type	Requirement and constraints
query	string	optional; minLength: 1; maxLength: 500; pattern: "\S"
collection_id	string	optional; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
organism	string	optional; minLength: 1; maxLength: 500; pattern: "\S"
tissue	string	optional; minLength: 1; maxLength: 500; pattern: "\S"
disease	string	optional; minLength: 1; maxLength: 500; pattern: "\S"
assay	string	optional; minLength: 1; maxLength: 500; pattern: "\S"
cell_type	string	optional; minLength: 1; maxLength: 500; pattern: "\S"
schema_version	string	optional; pattern: "^\d+(\.\d+){0,2}$"
page	integer	optional; default: 1; minimum: 1; maximum: 1000000
page_size	integer	optional; default: 25; minimum: 1; maximum: 100

const result = await host.mcp("cellxgene-discover", "list_datasets", {"organism":"NCBITaxon:9606","tissue":"liver","page_size":10})

get_dataset

Retrieve full current public dataset metadata, ontology annotations, citation, assets and version ID using canonical collection_id and dataset_id.

Field	Type	Requirement and constraints
collection_id	string	required; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
dataset_id	string	required; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"

const result = await host.mcp("cellxgene-discover", "get_dataset", {"collection_id":"9a71db9e-687f-41f0-b88e-544eb1314ef6","dataset_id":"0bbf93aa-2d3a-420f-95a1-26fe384024cb"})

list_collection_versions

List published versions of a canonical collection, newest first, retaining version IDs and dataset counts. Filtering and pagination are client-side over the complete API response, fetched on each call; results may change between calls. Save version IDs for reproducibility.

Field	Type	Requirement and constraints
collection_id	string	required; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
page	integer	optional; default: 1; minimum: 1; maximum: 1000000
page_size	integer	optional; default: 25; minimum: 1; maximum: 100

const result = await host.mcp("cellxgene-discover", "list_collection_versions", {"collection_id":"9a71db9e-687f-41f0-b88e-544eb1314ef6"})

get_collection_version

Retrieve a specific published collection_version_id and a page of its dataset versions; does not resolve to the latest collection. Filtering and pagination are client-side over the complete API response, fetched on each call; results may change between calls. Save version IDs for reproducibility.

Field	Type	Requirement and constraints
collection_version_id	string	required; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
page	integer	optional; default: 1; minimum: 1; maximum: 1000000
page_size	integer	optional; default: 25; minimum: 1; maximum: 100

const result = await host.mcp("cellxgene-discover", "get_collection_version", {"collection_version_id":"46ac9732-ff1c-4f87-86d7-0488d15aecd3"})

list_dataset_versions

List published versions of a canonical dataset_id, newest first, with schema version and publication dates. Filtering and pagination are client-side over the complete API response, fetched on each call; results may change between calls. Save version IDs for reproducibility.

Field	Type	Requirement and constraints
dataset_id	string	required; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
page	integer	optional; default: 1; minimum: 1; maximum: 1000000
page_size	integer	optional; default: 25; minimum: 1; maximum: 100

const result = await host.mcp("cellxgene-discover", "list_dataset_versions", {"dataset_id":"0bbf93aa-2d3a-420f-95a1-26fe384024cb"})

get_dataset_version

Retrieve full metadata and file assets for a specific published dataset_version_id. This ID is distinct from the canonical dataset_id.

Field	Type	Requirement and constraints
dataset_version_id	string	required; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"

const result = await host.mcp("cellxgene-discover", "get_dataset_version", {"dataset_version_id":"8e0fcb64-735c-4fcb-a74b-12a3518683d1"})

list_dataset_files

Return a download inventory from public dataset assets. Provide either dataset_version_id for a fixed publication, or both collection_id and dataset_id for the current version. After list_datasets with a schema_version filter, pass the returned dataset_version_id to preserve the selected publication. Returns API-provided H5AD/RDS/ATAC assets when available; no binary download, upload manifest or Census expression query.

Provide exactly one input group: dataset_version_id / collection_id + dataset_id.

Field	Type	Requirement and constraints
collection_id	string	subject to the conditions above; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
dataset_id	string	subject to the conditions above; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
dataset_version_id	string	subject to the conditions above; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"

const result = await host.mcp("cellxgene-discover", "list_dataset_files", {"dataset_version_id":"8e0fcb64-735c-4fcb-a74b-12a3518683d1"})

IEDB

Show operations and parameters

search_epitopes

Search IEDB epitopes with epitope, host, antigen source, MHC and evidence filters. Aggregated filters can match different experiments in the same record; use assay searches to enforce co-occurrence in one experiment. At least one biological or evidence filter is required; limit and offset alone are not filters. Database observations, not predictions. Keep negative and missing results distinct. MHC ligand elution is not a binding affinity measurement; interpret response_measured, method and units together. Parent antigens are representative proteins and may not exactly match the curated antigen or epitope sequence. Use cross_references.parent_uniprot_accessions or curated_uniprot_accessions with host.mcp("genes", "get_uniprot_entries", {accessions:[...]}); use cross_references.pdb_ids with host.mcp("structures", "pdb_get_structures", {pdb_ids:[...]}). These are explicit upstream cross-references, not sequence-derived mappings. Load each matching connector skill before calling it. Use either antigen_iri or uniprot_accession, not both.

Provide at least one of: epitope_id / reference_id / host_taxonomy_id / source_taxonomy_id / antigen_iri / uniprot_accession / mhc_allele / mhc_class / qualitative_measure / assay_iri / pdb_id / sequence.

Field	Type	Requirement and constraints
epitope_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
reference_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
host_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
source_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
antigen_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
uniprot_accession	string	subject to the conditions above; pattern: "^[A-Z0-9]{6}(?:[A-Z0-9]{4})?(?:-[1-9][0-9]*)?(?![\s\S])"
mhc_allele	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
mhc_class	string	subject to the conditions above; enum: ["I", "II"]
qualitative_measure	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
assay_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
pdb_id	string	subject to the conditions above; pattern: "^[0-9][A-Za-z0-9]{3}(?![\s\S])"
sequence	string	subject to the conditions above; maxLength: 1000; pattern: "^[A-Za-z]+(?![\s\S])"
limit	integer	optional; default: 20; minimum: 1; maximum: 100
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000

const result = await host.mcp("iedb", "search_epitopes", {"epitope_id": 25750, "limit": 20})

search_antigens

Search IEDB antigens with epitope, host, antigen source, MHC and evidence filters. Aggregated filters can match different experiments in the same record; use assay searches to enforce co-occurrence in one experiment. At least one biological or evidence filter is required; limit and offset alone are not filters. Database observations, not predictions. Keep negative and missing results distinct. MHC ligand elution is not a binding affinity measurement; interpret response_measured, method and units together. Parent antigens are representative proteins and may not exactly match the curated antigen or epitope sequence. Use cross_references.parent_uniprot_accessions or curated_uniprot_accessions with host.mcp("genes", "get_uniprot_entries", {accessions:[...]}); use cross_references.pdb_ids with host.mcp("structures", "pdb_get_structures", {pdb_ids:[...]}). These are explicit upstream cross-references, not sequence-derived mappings. Load each matching connector skill before calling it. Use either antigen_iri or uniprot_accession, not both.

Provide at least one of: epitope_id / reference_id / host_taxonomy_id / source_taxonomy_id / antigen_iri / uniprot_accession / mhc_allele / mhc_class / qualitative_measure / assay_iri / pdb_id / antigen_name.

Field	Type	Requirement and constraints
epitope_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
reference_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
host_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
source_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
antigen_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
uniprot_accession	string	subject to the conditions above; pattern: "^[A-Z0-9]{6}(?:[A-Z0-9]{4})?(?:-[1-9][0-9]*)?(?![\s\S])"
mhc_allele	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
mhc_class	string	subject to the conditions above; enum: ["I", "II"]
qualitative_measure	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
assay_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
pdb_id	string	subject to the conditions above; pattern: "^[0-9][A-Za-z0-9]{3}(?![\s\S])"
antigen_name	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
limit	integer	optional; default: 20; minimum: 1; maximum: 100
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000

const result = await host.mcp("iedb", "search_antigens", {"uniprot_accession": "P01012", "limit": 20})

search_tcell_assays

Search IEDB T cell experiments with host, source antigen, MHC and outcome filters. Includes tcell_export measurements, units, inequalities, methods, subject counts and publication locations. At least one biological or evidence filter is required; limit and offset alone are not filters. Database observations, not predictions. Keep negative and missing results distinct. MHC ligand elution is not a binding affinity measurement; interpret response_measured, method and units together. Parent antigens are representative proteins and may not exactly match the curated antigen or epitope sequence. Use cross_references.parent_uniprot_accessions or curated_uniprot_accessions with host.mcp("genes", "get_uniprot_entries", {accessions:[...]}); use cross_references.pdb_ids with host.mcp("structures", "pdb_get_structures", {pdb_ids:[...]}). These are explicit upstream cross-references, not sequence-derived mappings. Load each matching connector skill before calling it. Use either antigen_iri or uniprot_accession, not both.

Provide at least one of: epitope_id / reference_id / host_taxonomy_id / source_taxonomy_id / antigen_iri / uniprot_accession / mhc_allele / mhc_class / qualitative_measure / assay_iri / pdb_id / sequence / assay_id.

Field	Type	Requirement and constraints
epitope_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
reference_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
host_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
source_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
antigen_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
uniprot_accession	string	subject to the conditions above; pattern: "^[A-Z0-9]{6}(?:[A-Z0-9]{4})?(?:-[1-9][0-9]*)?(?![\s\S])"
mhc_allele	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
mhc_class	string	subject to the conditions above; enum: ["I", "II"]
qualitative_measure	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
assay_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
pdb_id	string	subject to the conditions above; pattern: "^[0-9][A-Za-z0-9]{3}(?![\s\S])"
sequence	string	subject to the conditions above; maxLength: 1000; pattern: "^[A-Za-z]+(?![\s\S])"
assay_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
limit	integer	optional; default: 20; minimum: 1; maximum: 100
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000

const result = await host.mcp("iedb", "search_tcell_assays", {"epitope_id": 25750, "limit": 20})

search_bcell_assays

Search IEDB B cell experiments with host, source antigen, MHC and outcome filters. Includes bcell_export measurements, units, inequalities, methods, subject counts and publication locations. At least one biological or evidence filter is required; limit and offset alone are not filters. Database observations, not predictions. Keep negative and missing results distinct. MHC ligand elution is not a binding affinity measurement; interpret response_measured, method and units together. Parent antigens are representative proteins and may not exactly match the curated antigen or epitope sequence. Use cross_references.parent_uniprot_accessions or curated_uniprot_accessions with host.mcp("genes", "get_uniprot_entries", {accessions:[...]}); use cross_references.pdb_ids with host.mcp("structures", "pdb_get_structures", {pdb_ids:[...]}). These are explicit upstream cross-references, not sequence-derived mappings. Load each matching connector skill before calling it. Use either antigen_iri or uniprot_accession, not both.

Provide at least one of: epitope_id / reference_id / host_taxonomy_id / source_taxonomy_id / antigen_iri / uniprot_accession / mhc_allele / mhc_class / qualitative_measure / assay_iri / pdb_id / sequence / assay_id.

Field	Type	Requirement and constraints
epitope_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
reference_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
host_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
source_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
antigen_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
uniprot_accession	string	subject to the conditions above; pattern: "^[A-Z0-9]{6}(?:[A-Z0-9]{4})?(?:-[1-9][0-9]*)?(?![\s\S])"
mhc_allele	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
mhc_class	string	subject to the conditions above; enum: ["I", "II"]
qualitative_measure	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
assay_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
pdb_id	string	subject to the conditions above; pattern: "^[0-9][A-Za-z0-9]{3}(?![\s\S])"
sequence	string	subject to the conditions above; maxLength: 1000; pattern: "^[A-Za-z]+(?![\s\S])"
assay_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
limit	integer	optional; default: 20; minimum: 1; maximum: 100
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000

const result = await host.mcp("iedb", "search_bcell_assays", {"epitope_id": 25750, "limit": 20})

search_mhc_assays

Search IEDB MHC binding and ligand elution experiments with host, source antigen, MHC and outcome filters. Includes mhc_export measurements, units, inequalities, methods, subject counts and publication locations. At least one biological or evidence filter is required; limit and offset alone are not filters. Database observations, not predictions. Keep negative and missing results distinct. MHC ligand elution is not a binding affinity measurement; interpret response_measured, method and units together. Parent antigens are representative proteins and may not exactly match the curated antigen or epitope sequence. Use cross_references.parent_uniprot_accessions or curated_uniprot_accessions with host.mcp("genes", "get_uniprot_entries", {accessions:[...]}); use cross_references.pdb_ids with host.mcp("structures", "pdb_get_structures", {pdb_ids:[...]}). These are explicit upstream cross-references, not sequence-derived mappings. Load each matching connector skill before calling it. Use either antigen_iri or uniprot_accession, not both.

Provide at least one of: epitope_id / reference_id / host_taxonomy_id / source_taxonomy_id / antigen_iri / uniprot_accession / mhc_allele / mhc_class / qualitative_measure / assay_iri / pdb_id / sequence / assay_id.

Field	Type	Requirement and constraints
epitope_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
reference_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
host_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
source_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
antigen_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
uniprot_accession	string	subject to the conditions above; pattern: "^[A-Z0-9]{6}(?:[A-Z0-9]{4})?(?:-[1-9][0-9]*)?(?![\s\S])"
mhc_allele	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
mhc_class	string	subject to the conditions above; enum: ["I", "II"]
qualitative_measure	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
assay_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
pdb_id	string	subject to the conditions above; pattern: "^[0-9][A-Za-z0-9]{3}(?![\s\S])"
sequence	string	subject to the conditions above; maxLength: 1000; pattern: "^[A-Za-z]+(?![\s\S])"
assay_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
limit	integer	optional; default: 20; minimum: 1; maximum: 100
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000

const result = await host.mcp("iedb", "search_mhc_assays", {"epitope_id": 25750, "limit": 20})

search_references

Search IEDB references with epitope, host, antigen source, MHC and evidence filters. Aggregated filters can match different experiments in the same record; use assay searches to enforce co-occurrence in one experiment. At least one biological or evidence filter is required; limit and offset alone are not filters. Database observations, not predictions. Keep negative and missing results distinct. MHC ligand elution is not a binding affinity measurement; interpret response_measured, method and units together. Parent antigens are representative proteins and may not exactly match the curated antigen or epitope sequence. Use cross_references.parent_uniprot_accessions or curated_uniprot_accessions with host.mcp("genes", "get_uniprot_entries", {accessions:[...]}); use cross_references.pdb_ids with host.mcp("structures", "pdb_get_structures", {pdb_ids:[...]}). These are explicit upstream cross-references, not sequence-derived mappings. Load each matching connector skill before calling it. Use either antigen_iri or uniprot_accession, not both.

Provide at least one of: epitope_id / reference_id / host_taxonomy_id / source_taxonomy_id / antigen_iri / uniprot_accession / mhc_allele / mhc_class / qualitative_measure / assay_iri / pdb_id / pubmed_id.

Field	Type	Requirement and constraints
epitope_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
reference_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
host_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
source_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
antigen_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
uniprot_accession	string	subject to the conditions above; pattern: "^[A-Z0-9]{6}(?:[A-Z0-9]{4})?(?:-[1-9][0-9]*)?(?![\s\S])"
mhc_allele	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
mhc_class	string	subject to the conditions above; enum: ["I", "II"]
qualitative_measure	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
assay_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
pdb_id	string	subject to the conditions above; pattern: "^[0-9][A-Za-z0-9]{3}(?![\s\S])"
pubmed_id	string	subject to the conditions above; maxLength: 12; pattern: "^[1-9][0-9]*(?![\s\S])"
limit	integer	optional; default: 20; minimum: 1; maximum: 100
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000

const result = await host.mcp("iedb", "search_references", {"reference_id": 1023094, "limit": 20})

search_tcrs

Search IEDB TCR receptor groups by epitope, receptor CDR3, host, antigen, MHC and literature evidence. The sequence filter matches epitope linear_sequences; chain1_cdr3 and chain2_cdr3 match receptor chain CDR3 sequences. Includes tcr_export records with chains, curated/calculated gene annotations and linked assays and references. Filters select receptor groups; embedded export records are not individually filtered by these criteria. Aggregated host and outcome filters can match different experiments in the same group. Receptor exports do not contain host or qualitative outcome fields. For experiment-level co-occurrence, follow the linked assay__iedb_ids and query search_tcell_assays, search_bcell_assays or search_mhc_assays with the corresponding assay_id and experimental filters. At least one biological or evidence filter is required; limit and offset alone are not filters. Database observations, not predictions. Keep negative and missing results distinct. MHC ligand elution is not a binding affinity measurement; interpret response_measured, method and units together. Parent antigens are representative proteins and may not exactly match the curated antigen or epitope sequence. Use cross_references.parent_uniprot_accessions or curated_uniprot_accessions with host.mcp("genes", "get_uniprot_entries", {accessions:[...]}); use cross_references.pdb_ids with host.mcp("structures", "pdb_get_structures", {pdb_ids:[...]}). These are explicit upstream cross-references, not sequence-derived mappings. Load each matching connector skill before calling it.

Provide at least one of: epitope_id / reference_id / host_taxonomy_id / source_taxonomy_id / antigen_iri / uniprot_accession / mhc_allele / mhc_class / qualitative_measure / assay_iri / pdb_id / sequence / receptor_group_id / chain1_cdr3 / chain2_cdr3.

Field	Type	Requirement and constraints
epitope_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
reference_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
host_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
source_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
antigen_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
uniprot_accession	string	subject to the conditions above; pattern: "^[A-Z0-9]{6}(?:[A-Z0-9]{4})?(?:-[1-9][0-9]*)?(?![\s\S])"
mhc_allele	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
mhc_class	string	subject to the conditions above; enum: ["I", "II"]
qualitative_measure	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
assay_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
pdb_id	string	subject to the conditions above; pattern: "^[0-9][A-Za-z0-9]{3}(?![\s\S])"
sequence	string	subject to the conditions above; maxLength: 1000; pattern: "^[A-Za-z]+(?![\s\S])"
receptor_group_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
chain1_cdr3	string	subject to the conditions above; maxLength: 1000; pattern: "^[A-Za-z]+(?![\s\S])"
chain2_cdr3	string	subject to the conditions above; maxLength: 1000; pattern: "^[A-Za-z]+(?![\s\S])"
limit	integer	optional; default: 20; minimum: 1; maximum: 100
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000

const result = await host.mcp("iedb", "search_tcrs", {"epitope_id": 25750, "limit": 20})

search_bcrs

Search IEDB BCR receptor groups by epitope, receptor CDR3, host, antigen, MHC and literature evidence. The sequence filter matches epitope linear_sequences; chain1_cdr3 and chain2_cdr3 match receptor chain CDR3 sequences. Includes bcr_export records with chains, curated/calculated gene annotations and linked assays and references. Filters select receptor groups; embedded export records are not individually filtered by these criteria. Aggregated host and outcome filters can match different experiments in the same group. Receptor exports do not contain host or qualitative outcome fields. For experiment-level co-occurrence, follow the linked assay__iedb_ids and query search_tcell_assays, search_bcell_assays or search_mhc_assays with the corresponding assay_id and experimental filters. At least one biological or evidence filter is required; limit and offset alone are not filters. Database observations, not predictions. Keep negative and missing results distinct. MHC ligand elution is not a binding affinity measurement; interpret response_measured, method and units together. Parent antigens are representative proteins and may not exactly match the curated antigen or epitope sequence. Use cross_references.parent_uniprot_accessions or curated_uniprot_accessions with host.mcp("genes", "get_uniprot_entries", {accessions:[...]}); use cross_references.pdb_ids with host.mcp("structures", "pdb_get_structures", {pdb_ids:[...]}). These are explicit upstream cross-references, not sequence-derived mappings. Load each matching connector skill before calling it.

Provide at least one of: epitope_id / reference_id / host_taxonomy_id / source_taxonomy_id / antigen_iri / uniprot_accession / mhc_allele / mhc_class / qualitative_measure / assay_iri / pdb_id / sequence / receptor_group_id / chain1_cdr3 / chain2_cdr3.

Field	Type	Requirement and constraints
epitope_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
reference_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
host_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
source_taxonomy_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
antigen_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
uniprot_accession	string	subject to the conditions above; pattern: "^[A-Z0-9]{6}(?:[A-Z0-9]{4})?(?:-[1-9][0-9]*)?(?![\s\S])"
mhc_allele	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
mhc_class	string	subject to the conditions above; enum: ["I", "II"]
qualitative_measure	string	subject to the conditions above; minLength: 1; maxLength: 300; pattern: "\S"
assay_iri	string	subject to the conditions above; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9_]:[A-Za-z0-9][A-Za-z0-9._:-](?![\s\S])"
pdb_id	string	subject to the conditions above; pattern: "^[0-9][A-Za-z0-9]{3}(?![\s\S])"
sequence	string	subject to the conditions above; maxLength: 1000; pattern: "^[A-Za-z]+(?![\s\S])"
receptor_group_id	integer	subject to the conditions above; minimum: 1; maximum: 9007199254740991
chain1_cdr3	string	subject to the conditions above; maxLength: 1000; pattern: "^[A-Za-z]+(?![\s\S])"
chain2_cdr3	string	subject to the conditions above; maxLength: 1000; pattern: "^[A-Za-z]+(?![\s\S])"
limit	integer	optional; default: 20; minimum: 1; maximum: 100
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000

const result = await host.mcp("iedb", "search_bcrs", {"epitope_id": 25750, "limit": 20})

Monarch Initiative

Show operations and parameters

monarch_get_disease_phenotypes

Retrieve disease–phenotype association evidence using Monarch canonical CURIEs, with relation/category, primary and aggregator sources, publications, evidence codes, negation, frequency, onset and disease context when supplied. Source database IDs and aliases are not automatically converted to Monarch canonical IDs and may return no matches. A zero total means no match for the supplied identifier and filters, not absence of phenotype evidence. Direct identifier matching is the default; direct does not mean experimentally proven. Inspect knowledge_level and agent_type for inferred associations. Missing evidence is not negative evidence. Use Genes & Ontologies for OLS term search and Alliance for model-organism records.

Field	Type	Requirement and constraints
disease_id	string	required; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9.-]*:[A-Za-z0-9][A-Za-z0-9.:-]*(?![\s\S])"
phenotype_id	string	optional; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9.-]*:[A-Za-z0-9][A-Za-z0-9.:-]*(?![\s\S])"
primary_knowledge_source	string	optional; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9.-]*:[A-Za-z0-9][A-Za-z0-9.:-]*(?![\s\S])"
direct	boolean	optional; default: true
limit	integer	optional; default: 20; minimum: 1; maximum: 100
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000

const result = await host.mcp("monarch", "monarch_get_disease_phenotypes", {"disease_id": "MONDO:0007947", "limit": 20})

monarch_get_gene_phenotypes

Retrieve gene–phenotype association evidence using Monarch canonical CURIEs, with relation/category, primary and aggregator sources, publications, evidence codes, negation, frequency, onset and disease context when supplied. Source database IDs and aliases are not automatically converted to Monarch canonical IDs and may return no matches. A zero total means no match for the supplied identifier and filters, not absence of phenotype evidence. Direct identifier matching is the default; direct does not mean experimentally proven. Inspect knowledge_level and agent_type for inferred associations. Missing evidence is not negative evidence. Use Genes & Ontologies for OLS term search and Alliance for model-organism records.

Field	Type	Requirement and constraints
gene_id	string	required; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9.-]*:[A-Za-z0-9][A-Za-z0-9.:-]*(?![\s\S])"
phenotype_id	string	optional; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9.-]*:[A-Za-z0-9][A-Za-z0-9.:-]*(?![\s\S])"
primary_knowledge_source	string	optional; maxLength: 200; pattern: "^[A-Za-z][A-Za-z0-9.-]*:[A-Za-z0-9][A-Za-z0-9.:-]*(?![\s\S])"
direct	boolean	optional; default: true
limit	integer	optional; default: 20; minimum: 1; maximum: 100
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000

const result = await host.mcp("monarch", "monarch_get_gene_phenotypes", {"gene_id": "HGNC:3603", "limit": 20})

Cellosaurus

Show operations and parameters

search_cell_lines

Search Cellosaurus recommended names and synonyms using a literal phrase (not raw Solr syntax). Returns candidates, not an unambiguous identity match. Use get_cell_line with the selected CVCL accession for origin, diseases and external mappings.

Field	Type	Requirement and constraints
query	string	required; minLength: 1; maxLength: 200; pattern: "\S"
limit	integer	optional; default: 20; minimum: 1; maximum: 100
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000

const result = await host.mcp("cellosaurus", "search_cell_lines", {"query": "HeLa", "limit": 20})

get_cell_line

Resolve a Cellosaurus CVCL accession or RRID:CVCL identifier. Retrieve identity, species, tissue/cell-type origin, establishing laboratory, donor disease/age/sex, parent cell lines, curated contamination/misidentification and caution records, ICLAC registrations, and external database mappings. Missing annotations do not establish sample quality.

Field	Type	Requirement and constraints
accession	string	required; minLength: 9; maxLength: 40; pattern: "^\s*(?:[Rr][Rr][Ii][Dd]:)?[Cc][Vv][Cc][Ll]_[A-Za-z0-9]{4}\s*$"

const result = await host.mcp("cellosaurus", "get_cell_line", {"accession": "RRID:CVCL_1906"})

get_cell_line_rdf

Retrieve RDF for one Cellosaurus accession from the official dereferencing service. The returned RDF text stays in the request result; there is no connector-owned file store or ontology download.

Field	Type	Requirement and constraints
accession	string	required; pattern: "^CVCL_[A-Z0-9]{4}$"
format	string	optional; default: "ttl"; enum: ["ttl", "rdf", "jsonld"]

const result = await host.mcp("cellosaurus", "get_cell_line_rdf", {"accession": "CVCL_0030", "format": "ttl"})

query_knowledge_graph

Run a bounded Cellosaurus SPARQL SELECT against the local official graph. Only PREFIX/SELECT queries without SERVICE, FROM or updates are supported; the supplied query is nested and limited, never broadened on zero results.

Field	Type	Requirement and constraints
query	string	required; minLength: 1; maxLength: 12000
max_rows	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("cellosaurus", "query_knowledge_graph", {"query": "SELECT ?s WHERE { ?s a <http://www.w3.org/2002/07/owl#Class> }", "max_rows": 2})

search_str_similarity

Compare an explicitly supplied cell-line STR profile with the official CLASTR service. Marker alleles are sent upstream. Similarity depends on loci and scoring options; it does not certify sample identity or absence of contamination.

Field	Type	Requirement and constraints
markers	object	required
species	string	optional; default: "human"; enum: ["human", "mouse", "dog"]
algorithm	integer	optional; default: 1; enum: [1, 2, 3]
scoring_mode	integer	optional; default: 1; enum: [1, 2, 3]
score_filter	integer	optional; default: 70; minimum: 0; maximum: 100
min_markers	integer	optional; default: 8; minimum: 1; maximum: 50
max_results	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("cellosaurus", "search_str_similarity", {"markers": {"D5S818": "12,13"}, "min_markers": 1, "max_results": 2})

list_cellosaurus_files

Discover official Cellosaurus data-file links. No ontology, file or dataset is downloaded or persisted automatically.

No input fields; pass an empty object.

const result = await host.mcp("cellosaurus", "list_cellosaurus_files", {})

PDC

Show operations and parameters

pdc_search_studies

Search PDC study identifiers and version names in the public study catalog. Keyword matching is case-insensitive local substring matching, not disease/clinical filtering. Without a keyword, browse the catalog. All versions are retained.

Field	Type	Requirement and constraints
query	string	optional; minLength: 1; maxLength: 200; pattern: "\S"
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000
limit	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("pdc", "pdc_search_studies", {"query":"CCRCC", "limit":5})

pdc_get_study

Retrieve PDC study metadata, assay type, case/aliquot counts, file categories and available versions. pdc_study_id selects the latest version; study_id is the UUID of a specific version. Use a returned study_id to pin subsequent calls. External reference IDs belong to the named resource; do not assume PDC and GDC UUIDs are interchangeable.

Provide exactly one of pdc_study_id / study_id.

Field	Type	Requirement and constraints
pdc_study_id	string	subject to the conditions above; maxLength: 9; pattern: "^PDC[0-9]{6}$"
study_id	string	subject to the conditions above; maxLength: 36; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"

const result = await host.mcp("pdc", "pdc_get_study", {"pdc_study_id":"PDC000127"})

pdc_list_biospecimens

Map PDC study aliquots to samples and cases, preserving submitter IDs, pool flags and external references for CPTAC multi-omics research. Each row is an aliquot association, not a unique patient. Use pagination_mode: upstream to traverse beyond the local mode's 1000-association upstream cap; upstream offsets and limits count cases. pdc_study_id selects the latest version; study_id is the UUID of a specific version. Use a returned study_id to pin subsequent calls. External reference IDs belong to the named resource; do not assume PDC and GDC UUIDs are interchangeable.

Provide exactly one of pdc_study_id / study_id.

Field	Type	Requirement and constraints
pdc_study_id	string	subject to the conditions above; maxLength: 9; pattern: "^PDC[0-9]{6}$"
study_id	string	subject to the conditions above; maxLength: 36; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000
limit	integer	optional; default: 20; minimum: 1; maximum: 100
pagination_mode	string	optional; default: "local"; enum: ["local", "upstream"]

const result = await host.mcp("pdc", "pdc_list_biospecimens", {"pdc_study_id":"PDC000127", "pagination_mode":"upstream", "limit":5})

pdc_list_files

Discover PDC study files, including quantitative reports (data_category: Protein Assembly) and publication supplements. Filters are passed to the official API. Returns metadata and storage paths, not file contents or download URLs. pdc_study_id selects the latest version; study_id is the UUID of a specific version. Use a returned study_id to pin subsequent calls. External reference IDs belong to the named resource; do not assume PDC and GDC UUIDs are interchangeable.

Provide exactly one of pdc_study_id / study_id.

Field	Type	Requirement and constraints
pdc_study_id	string	subject to the conditions above; maxLength: 9; pattern: "^PDC[0-9]{6}$"
study_id	string	subject to the conditions above; maxLength: 36; pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000
limit	integer	optional; default: 20; minimum: 1; maximum: 100
data_category	string	optional; minLength: 1; maxLength: 200; pattern: "\S"
file_type	string	optional; minLength: 1; maxLength: 200; pattern: "\S"
file_format	string	optional; minLength: 1; maxLength: 200; pattern: "\S"
file_name	string	optional; minLength: 1; maxLength: 500; pattern: "\S"

const result = await host.mcp("pdc", "pdc_list_files", {"pdc_study_id":"PDC000127", "data_category":"Protein Assembly", "limit":10})

pdc_list_clinical

Retrieve public PDC case demographics and diagnosis metadata, with available sample identifiers and named external references for linking to GDC. Values retain upstream types, nulls and obfuscation flags. pdc_study_id selects the latest version; study_id is the UUID of a specific version. Use a returned study_id to pin subsequent calls. External reference IDs belong to the named resource; do not assume PDC and GDC UUIDs are interchangeable.

Field	Type	Requirement and constraints
pdc_study_id	string	provide exactly one of these two identifiers; maxLength: 9
study_id	string	provide exactly one of these two identifiers; maxLength: 36
offset	integer	optional; default: 0; minimum: 0; maximum: 1000000
limit	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("pdc", "pdc_list_clinical", {"pdc_study_id": "PDC000127", "limit": 10})

ENCORI

Show operations and parameters

query_mirna_targets

Query official miRNA target evidence. Use mirna=all for unrestricted miRNA; preserve cell_type exactly. program is a comma-separated list of PITA, RNA22, miRmap, DIANA-microT, miRanda, PicTar or TargetScan, never all.

Field	Type	Requirement and constraints
assembly	string	required; enum: ["hg38", "mm10"]
gene_type	string	required; enum: ["mRNA", "lncRNA", "pseudogene", "circRNA", "sncRNA"]
mirna	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
clip_exp_num	integer	required; minimum: 0; maximum: 999
degra_exp_num	integer	required; minimum: 0; maximum: 999
pancancer_num	integer	required; minimum: 0; maximum: 32
program_num	integer	required; minimum: 1; maximum: 7
program	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
target	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
cell_type	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
max_records	integer	optional; default: 20; minimum: 1; maximum: 200
output_dir	['string', 'null']	optional; minLength: 1; maxLength: 4096

const result = await host.mcp("encori", "query_mirna_targets", {"assembly":"hg38","gene_type":"mRNA","mirna":"all","clip_exp_num":1,"degra_exp_num":0,"pancancer_num":0,"program_num":1,"program":"TargetScan","target":"PDCD4","cell_type":"HeLa","max_records":2})

query_rna_rna_interactions

Query official RNA–RNA interactions. Use cell_type=all only when unrestricted; do not substitute another database.

Field	Type	Requirement and constraints
assembly	string	required; enum: ["hg38", "mm10"]
gene_type	string	required; enum: ["mRNA", "lncRNA", "pseudogene", "sncRNA", "miRNA"]
rna	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
inter_num	integer	required; minimum: 1; maximum: 999
exp_num	integer	required; minimum: 1; maximum: 999
cell_type	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
max_records	integer	optional; default: 20; minimum: 1; maximum: 200
output_dir	['string', 'null']	optional; minLength: 1; maxLength: 4096

const result = await host.mcp("encori", "query_rna_rna_interactions", {"assembly":"hg38","gene_type":"mRNA","rna":"TP53","inter_num":1,"exp_num":1,"cell_type":"all","max_records":2})

query_rbp_targets

Query official RBP target evidence. Use rbp=all for all RBPs; preserve cell_type and distinguish zero rows from request failure.

Field	Type	Requirement and constraints
assembly	string	required; enum: ["hg38", "mm10", "dm6", "ce10", "sacCer3"]
gene_type	string	required; enum: ["mRNA", "lncRNA", "pseudogene", "circRNA", "sncRNA"]
rbp	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
clip_exp_num	integer	required; minimum: 1; maximum: 999
pancancer_num	integer	required; minimum: 0; maximum: 32
target	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
cell_type	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
max_records	integer	optional; default: 20; minimum: 1; maximum: 200
output_dir	['string', 'null']	optional; minLength: 1; maxLength: 4096

const result = await host.mcp("encori", "query_rbp_targets", {"assembly":"hg38","gene_type":"mRNA","rbp":"all","clip_exp_num":1,"pancancer_num":0,"target":"TP53","cell_type":"HeLa","max_records":2})

query_cerna_network

Query official ceRNA networks. Use family=all when unrestricted. Preserve official P values and FDR; never infer missing family names from counts.

Field	Type	Requirement and constraints
assembly	string	required; enum: ["hg38", "mm10"]
gene_type	string	required; enum: ["mRNA", "lncRNA", "pseudogene"]
cerna	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
mirna_num	integer	required; minimum: 1; maximum: 999
family	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
pval	number	required; minimum: 0; maximum: 0.01
fdr	number	required; minimum: 0; maximum: 0.01
pancancer_num	integer	required; minimum: 0; maximum: 32
max_records	integer	optional; default: 20; minimum: 1; maximum: 200
output_dir	['string', 'null']	optional; minLength: 1; maxLength: 4096

const result = await host.mcp("encori", "query_cerna_network", {"assembly":"hg38","gene_type":"mRNA","cerna":"MYC","mirna_num":1,"family":"all","pval":0.01,"fdr":0.01,"pancancer_num":0,"max_records":2})

query_rbp_disease

Query official RBP disease evidence. Preserve tissue, disease and target filters without widening zero-result queries.

Field	Type	Requirement and constraints
assembly	string	required; enum: ["hg38"]
rbp	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
tissue	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
disease	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
target	string	required; minLength: 1; maxLength: 256; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
max_records	integer	optional; default: 20; minimum: 1; maximum: 200
output_dir	['string', 'null']	optional; minLength: 1; maxLength: 4096

const result = await host.mcp("encori", "query_rbp_disease", {"assembly":"hg38","rbp":"all","tissue":"breast","disease":"carcinoma","target":"MYC","max_records":2})

scan_rbp_motifs

Search official RBP motif rankings. Preserve order and scores. QueryMotif and IdentifiedMotif are independent fields; no reverse complement is performed or inferred.

Field	Type	Requirement and constraints
assembly	string	required; enum: ["hg38", "mm10", "dm6", "ce10", "sacCer3"]
length	string	required; enum: ["short", "long"]
motif	string	required; minLength: 1; maxLength: 64; pattern: "^[ACGTUNRYKMSWBDHVacgtunrykmswbdhv]+$"
rank_limit	integer	required; minimum: 1; maximum: 100
max_records	integer	optional; default: 20; minimum: 1; maximum: 200
output_dir	['string', 'null']	optional; minLength: 1; maxLength: 4096

const result = await host.mcp("encori", "scan_rbp_motifs", {"assembly":"hg38","length":"short","motif":"UGCAUG","rank_limit":10,"max_records":2})

get_binding_sites

Retrieve official BED binding sites by dataset_id. Remove only known SQL prefixes from parsed records; retain exact raw bytes.

Field	Type	Requirement and constraints
assembly	string	required; enum: ["hg38", "mm10", "dm6", "ce10", "sacCer3"]
dataset_id	string	required; minLength: 1; maxLength: 64; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
max_records	integer	optional; default: 100; minimum: 1; maximum: 1000
output_dir	['string', 'null']	optional; minLength: 1; maxLength: 4096

const result = await host.mcp("encori", "get_binding_sites", {"assembly":"hg38","dataset_id":"SBDH2131","max_records":2})

get_reference_tables

List exact table names from the online official reference ZIP, or read one exact table_name such as reference_data/degradome_ref.txt. Fetches the ZIP anew on each call.

Field	Type	Requirement and constraints
table_name	['string', 'null']	optional; minLength: 1; maxLength: 512; pattern: "^[^\r\n\u0000][^\s\u0000][^\r\n\u0000]$"
max_records	integer	optional; default: 50; minimum: 1; maximum: 500
output_dir	['string', 'null']	optional; minLength: 1; maxLength: 4096

const result = await host.mcp("encori", "get_reference_tables", {"table_name":"reference_data/degradome_ref.txt","max_records":2})

list_bulk_datasets

List the 24 documented official bulk dataset filenames. By default HEAD probes availability and byte sizes, without downloading data. Unchecked availability and size are null.

Field	Type	Requirement and constraints
assembly	['string', 'null']	optional; enum: ["hg38", "mm10", null]
data_type	['string', 'null']	optional; enum: ["miRNA_mRNA", "miRNA_lncRNA", "miRNA_pseudogene", "miRNA_sncRNA", "miRNA_circRNA", "RNA_RNA", "RBP_mRNA", "RBP_lncRNA", "RBP_pseudogene", "RBP_sncRNA", "RBP_circRNA", "RBP_caRNA", null]
check_availability	boolean	optional; default: true

const result = await host.mcp("encori", "list_bulk_datasets", {"assembly":"hg38","data_type":"miRNA_mRNA"})

download_bulk_dataset

Only when the user requests a download, stream one official bulk file to destination_dir on the computer running the caller. Never overwrite an existing file. Interrupted .part files resume on the same filename/directory only after identity and HTTP range validation. Validate size and gzip integrity before publication.

Field	Type	Requirement and constraints
filename	string	required; enum: ["hg38.miRNA_mRNA.tar.gz", "hg38.miRNA_lncRNA.tar.gz", "hg38.miRNA_pseudogene.tar.gz", "hg38.miRNA_sncRNA.tar.gz", "hg38.miRNA_circRNA.tar.gz", "hg38.RNA_RNA.tar.gz", "hg38.RBP_mRNA.tar.gz", "hg38.RBP_lncRNA.tar.gz", "hg38.RBP_pseudogene.tar.gz", "hg38.RBP_sncRNA.tar.gz", "hg38.RBP_circRNA.tar.gz", "hg38.RBP_caRNA.tar.gz", "mm10.miRNA_mRNA.tar.gz", "mm10.miRNA_lncRNA.tar.gz", "mm10.miRNA_pseudogene.tar.gz", "mm10.miRNA_sncRNA.tar.gz", "mm10.miRNA_circRNA.tar.gz", "mm10.RNA_RNA.tar.gz", "mm10.RBP_mRNA.tar.gz", "mm10.RBP_lncRNA.tar.gz", "mm10.RBP_pseudogene.tar.gz", "mm10.RBP_sncRNA.tar.gz", "mm10.RBP_circRNA.tar.gz", "mm10.RBP_caRNA.tar.gz"]
destination_dir	['string', 'null']	optional; minLength: 1; maxLength: 4096

const result = await host.mcp("encori", "download_bulk_dataset", {"filename":"hg38.miRNA_sncRNA.tar.gz","destination_dir":"/absolute/path/to/output"})

Orphadata

get_disease_genes

Retrieve Orphadata rare-disease gene associations by ORPHAcode, including association type/status, validation sources and gene database mappings.

Field	Type	Requirement and constraints
orphacode	integer	required; minimum: 1; maximum: 2147483647

const result = await host.mcp("orphadata", "get_disease_genes", {"orphacode": 166024})

get_disease_phenotypes

Retrieve Orphadata rare-disease HPO phenotypes and frequency categories by ORPHAcode. Keeps diagnostic criteria and validation metadata; frequency categories are not patient-specific probabilities.

Field	Type	Requirement and constraints
orphacode	integer	required; minimum: 1; maximum: 2147483647

const result = await host.mcp("orphadata", "get_disease_phenotypes", {"orphacode": 58})

TCIA

Show operations and parameters

search_collections

Search public TCIA collections by keyword, one page at a time. Includes cancer, modality, DOI and download requirements. Collection Manager and NBIA have different coverage. Download links may be Data Retriever manifests, not images. Does not download DICOM or access restricted data.

Field	Type	Requirement and constraints
query	string	required; minLength: 1; maxLength: 200; pattern: "\S"
page	integer	optional; minimum: 1; maximum: 1000
page_size	integer	optional; minimum: 1; maximum: 20

const result = await host.mcp("tcia", "search_collections", {"query": "LIDC-IDRI", "page_size": 5})

get_collection

Find one TCIA collection by exact short title returned by search_collections. Searches up to 20 candidates and verifies identity: the upstream include=id filter is unreliable. A null result with lookup_complete=false means refine the lookup, not absence. Returns license and downloader requirements; does not download files.

Field	Type	Requirement and constraints
short_title	string	required; minLength: 1; maxLength: 200; pattern: "\S"

const result = await host.mcp("tcia", "get_collection", {"short_title": "4D-Lung"})

get_series

Retrieve public NBIA metadata for an exact DICOM SeriesInstanceUID: collection, subject/study identity, modality, image count, byte size and license. Use an existing UID from TCIA; no broad enumeration or image download. This endpoint does not cover every TCIA collection.

Field	Type	Requirement and constraints
series_uid	string	required; maxLength: 64; pattern: "^[0-9]+(?:\.[0-9]+)+$"

const result = await host.mcp("tcia", "get_series", {"series_uid": "1.3.6.1.4.1.14519.5.2.1.6834.5010.189721824525842725510380467695"})

KEGG

Show operations and parameters

search_entries

Search KEGG pathway, KO, compound or reaction names. Returns a capped list, not server-side pagination; narrow the query when truncated. Public KEGG API is for eligible academic use only; non-academic use and service provision require appropriate licensing. Enabling this connector does not grant a license.

Field	Type	Requirement and constraints
database	string	required; enum: ["pathway", "ko", "compound", "reaction"]
query	string	required; minLength: 1; maxLength: 200; pattern: "\S"
limit	integer	optional; minimum: 1; maximum: 100

const result = await host.mcp("kegg", "search_entries", {"database": "pathway", "query": "glycolysis"})

get_entry

Read one KEGG pathway, KO, compound or reaction summary. Returns selected flatfile fields with explicit truncation; excludes bulk GENES, sequences and pathway images. HTTP 404 is not an empty record. Public KEGG API is for eligible academic use only; non-academic use and service provision require appropriate licensing. Enabling this connector does not grant a license.

Field	Type	Requirement and constraints
id	string	required; pattern: "^(?:[KCR][0-9]{5}|(?:map|[a-z]{3,4})[0-9]{5})$"

const result = await host.mcp("kegg", "get_entry", {"id": "hsa00010"})

map_gene

Map one organism-qualified KEGG gene to pathways or UniProt accessions. Preserves one-to-many matches; no automatic choice of a canonical protein. Results are capped without server-side pagination. Public KEGG API is for eligible academic use only; non-academic use and service provision require appropriate licensing. Enabling this connector does not grant a license.

Field	Type	Requirement and constraints
gene	string	required; maxLength: 80; pattern: "^[a-z][a-z0-9]{1,4}:[A-Za-z0-9_.-]+$"
target	string	required; enum: ["pathway", "uniprot"]
limit	integer	optional; minimum: 1; maximum: 100

const result = await host.mcp("kegg", "map_gene", {"gene": "hsa:7157", "target": "uniprot"})

RxNorm / RxNav

Show operations and parameters

resolve_name

Resolve a drug name to active RxNorm RxCUIs. Exact matching is the default; normalized matching can ignore salts and word order. Retains all ambiguous matches and does not establish clinical equivalence.

Field	Type	Requirement and constraints
name	string	required; minLength: 1; maxLength: 300; pattern: "\S"
search	integer	optional; enum: [0, 1, 2]

const result = await host.mcp("rxnorm", "resolve_name", {"name": "aspirin"})

get_concept

Retrieve active RxNorm concept properties by RxCUI: name, synonym, term type, language and suppression flag. An absent record is not proof that an identifier never existed.

Field	Type	Requirement and constraints
rxcui	string	required; pattern: "^[0-9]{1,12}$"

const result = await host.mcp("rxnorm", "get_concept", {"rxcui": "1191"})

DailyMed

Show operations and parameters

search_labels

Search DailyMed SPL label identities, titles, versions and publication dates by drug name, optionally narrowed to an RxCUI. Retrieves one metadata page; label presence does not establish FDA approval.

Field	Type	Requirement and constraints
drug_name	string	required; minLength: 1; maxLength: 300; pattern: "\S"
rxcui	string	optional; pattern: "^[0-9]{1,12}$"
page	integer	optional; default: 1; minimum: 1; maximum: 100000
page_size	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("dailymed", "search_labels", {"drug_name": "aspirin", "page_size": 5})

get_label_history

Retrieve one page of DailyMed SPL version history for an exact SET ID, preserving the label identity, title and publication dates. Does not download historical label content.

Field	Type	Requirement and constraints
setid	string	required; pattern: "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$"
page	integer	optional; default: 1; minimum: 1; maximum: 100000
page_size	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("dailymed", "get_label_history", {"setid": "9aa7140c-012c-4ea6-866d-4732e915dab6"})

BioSamples

Show operations and parameters

search_samples

Search public EMBL-EBI BioSamples metadata, one cursor page at a time. Retains characteristics, ontology terms, external references and release/update dates. Use the returned next_cursor with unchanged query and page_size; no automatic traversal.

Field	Type	Requirement and constraints
query	string	required; minLength: 1; maxLength: 500; pattern: "\S"
page_size	integer	optional; default: 20; minimum: 1; maximum: 100
cursor	string	optional; minLength: 1; maxLength: 2048; pattern: "\S"

const result = await host.mcp("biosamples", "search_samples", {"query": "leukaemia", "page_size": 5})

get_sample

Retrieve a public BioSamples record by accession, with default applied curations, characteristics, ontology terms, relationships, external references and provenance dates. Linked resources and files are not fetched.

Field	Type	Requirement and constraints
accession	string	required; pattern: "^SAM[END][A-Z]?[0-9]{1,15}$"

const result = await host.mcp("biosamples", "get_sample", {"accession": "SAMD00023550"})

WikiPathways

Show operations and parameters

search_pathways

Find WikiPathways by case-insensitive name or WP identifier substring, optionally restricted to an exact scientific species name. Filters the current official listPathways JSON snapshot locally; this is not full-text or gene search.

Field	Type	Requirement and constraints
query	string	required; minLength: 1; maxLength: 300; pattern: "\S"
species	string	optional; minLength: 1; maxLength: 100; pattern: "\S"
offset	integer	optional; default: 0; minimum: 0; maximum: 100000
limit	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("wikipathways", "search_pathways", {"query": "glycolysis", "species": "Homo sapiens"})

get_pathway

Retrieve one WikiPathways metadata record by WP identifier from the current getPathwayInfo JSON snapshot. Preserves species, revision, authors, source description and citations. Does not retrieve pathway graphs, gene mappings or historical revisions.

Field	Type	Requirement and constraints
id	string	required; pattern: "^WP[0-9]{1,10}$"

const result = await host.mcp("wikipathways", "get_pathway", {"id": "WP534"})

Europe PMC

Show operations and parameters

search_europepmc

Search Europe PMC directly using Boolean, field and date syntax. Returns core records including actual available abstracts and an explicit pagination cursor. Public: no NCBI key or contact email is required for this method. A full-text URL is not retrieved full text; follow PMC identifiers using the existing full-text tools.

Field	Type	Requirement and constraints
query	string	required; minLength: 1; maxLength: 12000
page_size	integer	optional; default: 20; minimum: 1; maximum: 100
cursor	string	optional; default: "*"; minLength: 1; maxLength: 4096

const result = await host.mcp("europepmc", "search_europepmc", {"query": "TP53 AND liver fibrosis", "page_size": 5})

Research Datasets

Show operations and parameters

get_dataset_access

Read official access requirements and entry points for NHANES, CHARLS, CHNS, SEER, MIMIC, eICU, FAERS or GBD. This is declared guidance, not an account check, approval or a query of the source database. Recheck current official terms before acquisition.

Field	Type	Requirement and constraints
dataset	string	required; enum: ["nhanes", "charls", "chns", "seer", "mimic", "eicu", "faers", "gbd"]

const result = await host.mcp("research-datasets", "get_dataset_access", {"dataset": "seer"})

list_nhanes_files

Discover official public NHANES XPT files for one survey cycle/component. Returns file and matching documentation links without downloading files. Rejects a changed/challenge page rather than treating it as an empty dataset.

Field	Type	Requirement and constraints
cycle_begin_year	integer	required; minimum: 1999; maximum: 2100
component	string	optional; default: "Demographics"; enum: ["Demographics", "Dietary", "Examination", "Laboratory", "Questionnaire"]

const result = await host.mcp("research-datasets", "list_nhanes_files", {"cycle_begin_year": 2017, "component": "Demographics"})

list_physionet_demo_files

List files in the official MIMIC-IV 2.2 or eICU 2.0 public demo. Supports fixed demo locations only; this never probes credentialed projects, accepts arbitrary URLs or sends account credentials.

Field	Type	Requirement and constraints
dataset	string	required; enum: ["mimic", "eicu"]
directory	string	optional; default: "root"; enum: ["root", "hosp", "icu"]

const result = await host.mcp("research-datasets", "list_physionet_demo_files", {"dataset": "mimic", "directory": "hosp"})

ChEA3

Show operations and parameters

rank_transcription_factors

Submit a public gene-symbol list to the official ChEA3 enrichment API. Returns each library ranking separately; ranks and scores are hypothesis evidence, not causal validation. The request is submitted once and does not identify all recognized input genes.

Field	Type	Requirement and constraints
genes	array	required; minItems: 1; maxItems: 2000
query_name	string	optional; default: "query"; minLength: 1; maxLength: 100
top_n	integer	optional; default: 20; minimum: 1; maximum: 100

const result = await host.mcp("chea3", "rank_transcription_factors", {"genes": ["FOXM1", "SMAD9", "MYC", "SMAD3", "STAT1", "STAT3"], "top_n": 5})

list_gmt_libraries

Discover official ChEA3 GMT file links from its download page. Primary, additional and benchmarking libraries may differ; a downloadable library is not automatically the library used by an online result. No files are downloaded by this method.

No input fields; pass an empty object.

const result = await host.mcp("chea3", "list_gmt_libraries", {})

bioDBnet

Show operations and parameters

list_input_types

Call the official bioDBnet getinputs REST operation. Discover supported node names before conversion. Preserve unmapped inputs and multiple outputs; absence is not proof that no biological mapping exists.

No input fields; pass an empty object.

const result = await host.mcp("biodbnet", "list_input_types", {})

list_output_types

Call the official bioDBnet getoutputsforinput REST operation. Discover supported node names before conversion. Preserve unmapped inputs and multiple outputs; absence is not proof that no biological mapping exists.

Field	Type	Requirement and constraints
input_type	string	required; minLength: 1; maxLength: 80; pattern: "^[A-Za-z0-9 _-]+$"

const result = await host.mcp("biodbnet", "list_output_types", {"input_type": "genesymbol"})

convert_ids

Call the official bioDBnet db2db REST operation. Discover supported node names before conversion. Preserve unmapped inputs and multiple outputs; absence is not proof that no biological mapping exists.

Field	Type	Requirement and constraints
input_type	string	required; minLength: 1; maxLength: 80; pattern: "^[A-Za-z0-9 _-]+$"
values	array	required; minItems: 1; maxItems: 200
outputs	array	required; minItems: 1; maxItems: 20
taxon_id	integer	optional; default: 9606; minimum: 1; maximum: 100000000

const result = await host.mcp("biodbnet", "convert_ids", {"input_type": "genesymbol", "values": ["TP53"], "outputs": ["geneid"], "taxon_id": 9606})

recognize_ids

Call the official bioDBnet dbfind REST operation. Discover supported node names before conversion. Preserve unmapped inputs and multiple outputs; absence is not proof that no biological mapping exists.

Field	Type	Requirement and constraints
values	array	required; minItems: 1; maxItems: 200
output_type	string	required; minLength: 1; maxLength: 80; pattern: "^[A-Za-z0-9 _-]+$"
taxon_id	integer	optional; default: 9606; minimum: 1; maximum: 100000000

const result = await host.mcp("biodbnet", "recognize_ids", {"values": ["TP53"], "output_type": "geneid"})

map_orthologs

Call the official bioDBnet dbortho REST operation. Discover supported node names before conversion. Preserve unmapped inputs and multiple outputs; absence is not proof that no biological mapping exists.

Field	Type	Requirement and constraints
input_type	string	required; minLength: 1; maxLength: 80; pattern: "^[A-Za-z0-9 _-]+$"
values	array	required; minItems: 1; maxItems: 200
input_taxon	integer	optional; default: 9606; minimum: 1; maximum: 100000000
output_taxon	integer	optional; default: 10090; minimum: 1; maximum: 100000000
output_type	string	required; minLength: 1; maxLength: 80; pattern: "^[A-Za-z0-9 _-]+$"

const result = await host.mcp("biodbnet", "map_orthologs", {"input_type": "genesymbol", "values": ["TP53"], "output_type": "genesymbol", "input_taxon": 9606, "output_taxon": 10090})

list_pathways

Call the official bioDBnet getpathways REST operation. Discover supported node names before conversion. Preserve unmapped inputs and multiple outputs; absence is not proof that no biological mapping exists.

Field	Type	Requirement and constraints
taxon_id	integer	optional; default: 9606; minimum: 1; maximum: 100000000

const result = await host.mcp("biodbnet", "list_pathways", {"taxon_id": 9606})

CTD

Show operations and parameters

list_ctd_reports

Return a maintained subset of official CTD public report entry points and source terms. This static catalog does not verify live availability or provide CTD web queries. Use the official page to obtain files; stop if human verification is required.

No input fields; pass an empty object.

const result = await host.mcp("ctd", "list_ctd_reports", {})