Server definition

Hash: sha256:55a6427d0a76d50c3b1ef028563c4324c3a15f88fb2573a292680ea38d6c239f
What it is: What a remote MCP server returned when asked what it offers: 15 tools

The blob, as servednamed by its sha256

{
  "instructions": "DNA sequence analysis with Genomic Intelligence models. Research use only, not for clinical or diagnostic decisions.\n\nFirst get a sequence handle (fetch_ensembl_sequence, fetch_region, fetch_gene_for_expression, load_demo_sequence or store_inline_sequence), then pass its sequence_ref to a predict tool or find_genes; large sequences then stay out of the conversation. Short sequences can go inline as `sequence`. For expression of every gene in a region, use find_genes_and_predict_expression.\n\nEach tool states its length limits; list_models gives each model's bio_spec.",
  "tools": [
    {
      "description": "Fetch a gene's reference sequence from Ensembl and store it.\n\n        Returns a handle ({ref, name, length, preview, ...}). Pass the\n        `ref` to predict_* tools — the bases stay server-side. For\n        expression, use fetch_gene_for_expression instead (it prepares\n        the TSS-centred window that model needs).\n        ",
      "inputSchema": {
        "properties": {
          "flank_bp": {
            "default": 0,
            "description": "Extra bp added on each side of the gene body.",
            "minimum": 0,
            "title": "Flank Bp",
            "type": "integer"
          },
          "gene": {
            "description": "Gene symbol (e.g. 'TP53') or Ensembl ID.",
            "title": "Gene",
            "type": "string"
          },
          "species": {
            "default": "human",
            "description": "Species name, e.g. 'human', 'mouse'.",
            "title": "Species",
            "type": "string"
          }
        },
        "required": [
          "gene"
        ],
        "title": "fetch_ensembl_sequenceArguments",
        "type": "object"
      },
      "name": "fetch_ensembl_sequence",
      "outputSchema": {
        "additionalProperties": true,
        "title": "fetch_ensembl_sequenceDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Fetch a gene's sequence prepared for expression prediction.\n\n        Resolves the gene's canonical-transcript TSS via Ensembl and stores a\n        gene-sense sequence centred on it, as a handle to pass to\n        predict_expression(sequence_ref=...). Longer TSS-centred sequence\n        gives better predictions, so this already fetches as much flank on\n        each side of the TSS as the listed expression models recommend (the\n        largest bio_spec.recommended_flank_bp from list_models). One handle\n        serves every expression model: the API reads what the chosen model\n        needs around the TSS and ignores the rest.\n\n        The handle records `tss_index` (the TSS offset into it), and\n        predict_expression uses it when you do not pass one, so no offset\n        arithmetic is needed. Every expression model accepts at least\n        9,198 bp with the TSS at least 4,599 bp from each end. Near a\n        chromosome end the flank is shortened to what fits (reported as\n        `flank_shortened`), never below 4,599 bp; a TSS closer to the end\n        than that is an error.\n        ",
      "inputSchema": {
        "properties": {
          "gene": {
            "description": "Gene symbol (e.g. 'HBB').",
            "title": "Gene",
            "type": "string"
          },
          "species": {
            "default": "human",
            "description": "Species name.",
            "title": "Species",
            "type": "string"
          }
        },
        "required": [
          "gene"
        ],
        "title": "fetch_gene_for_expressionArguments",
        "type": "object"
      },
      "name": "fetch_gene_for_expression",
      "outputSchema": {
        "additionalProperties": true,
        "title": "fetch_gene_for_expressionDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Fetch a genomic region by coordinates from Ensembl and store it.\n\n        For \"find the genes in chr8:127,680,000-127,800,000\"-style requests:\n        resolves a coordinate range to reference sequence and returns a handle\n        ({ref, name, length, ...}) to pass to find_genes / predict_* — the bases\n        stay server-side. Plus strand by default, which is what the gene-finder\n        expects. For a gene by name use fetch_ensembl_sequence; for expression\n        use fetch_gene_for_expression.\n        ",
      "inputSchema": {
        "properties": {
          "flank_bp": {
            "default": 0,
            "description": "Extra bp added on each side of the region.",
            "minimum": 0,
            "title": "Flank Bp",
            "type": "integer"
          },
          "region": {
            "description": "Genomic coordinates, e.g. 'chr8:127,680,000-127,800,000'. Commas, en/em dashes and '..' are accepted; the 'chr' prefix is optional.",
            "title": "Region",
            "type": "string"
          },
          "species": {
            "default": "human",
            "description": "Species name, e.g. 'human', 'mouse'.",
            "title": "Species",
            "type": "string"
          },
          "strand": {
            "default": 1,
            "description": "1 = plus (default), -1 = minus. find_genes (gene finding) is plus-oriented — keep 1 for annotation; use -1 only for a strand-sensitive task on a known minus-strand locus.",
            "title": "Strand",
            "type": "integer"
          }
        },
        "required": [
          "region"
        ],
        "title": "fetch_regionArguments",
        "type": "object"
      },
      "name": "fetch_region",
      "outputSchema": {
        "additionalProperties": true,
        "title": "fetch_regionDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Find genes (transcript intervals) in a genomic region (async, ~8-25s).\n\n        Takes 1,000–500,000 bp. The floor is the strictest of the scanning\n        tasks: gene finding needs a region, not a site. (Only expression's\n        9,198 bp is higher, and that is the sequence around one TSS rather\n        than a region to search.)\n\n        Gene-finding: detects transcript boundaries (TSS + PolyA) and returns\n        one interval per predicted transcript — start/end, strand, a\n        confidence score, and predicted TSS/PolyA positions (BED-style feature\n        intervals, not free-text notes). Use this for \"what genes are here\",\n        \"find / locate genes\", or \"annotate this region\".\n\n        Each transcript also carries its type (mRNA/lnc_RNA) and internal\n        exon/intron/CDS structure in `exons`/`introns`/`cds` arrays, plus a\n        browser-ready GFF3 track in `data.formats.gff3`. To get each gene's\n        *expression* from a raw region, use find_genes_and_predict_expression\n        instead — expression needs a per-gene TSS window, so predict_expression\n        cannot run on a whole region.\n\n        Submits an async job internally. With wait=True (default), blocks and\n        streams progress, then returns the result {data, meta} — it never\n        returns a job_id on this path. (If a generous block ceiling is\n        exceeded it returns a timeout error, not a job handle.) With\n        wait=False (detached), returns {data: {job_id, status: 'submitted'}}\n        immediately — poll it with get_job.\n        ",
      "inputSchema": {
        "properties": {
          "model": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional model id; omit for the task default. See list_models.",
            "title": "Model"
          },
          "sequence": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "DNA bases A/C/G/T/N (case-insensitive). Line breaks are ignored (a wrapped FASTA body may be pasted verbatim; a `>` header line may not). Mutually exclusive with `sequence_ref`.",
            "title": "Sequence"
          },
          "sequence_name": {
            "default": "sequence",
            "description": "Label echoed back in the response (ignored when `sequence_ref` is used).",
            "title": "Sequence Name",
            "type": "string"
          },
          "sequence_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Handle (seq_…) from any acquisition tool (fetch_ensembl_sequence, fetch_region, fetch_gene_for_expression, load_demo_sequence, load_local_fasta, store_inline_sequence). Mutually exclusive with `sequence`.",
            "title": "Sequence Ref"
          },
          "wait": {
            "default": true,
            "description": "Default True: block and stream progress until the result is ready. Set False for detached mode — returns a job_id immediately to poll with get_job.",
            "title": "Wait",
            "type": "boolean"
          }
        },
        "title": "find_genesArguments",
        "type": "object"
      },
      "name": "find_genes",
      "outputSchema": {
        "additionalProperties": true,
        "title": "find_genesDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Find genes in a sequence, then predict each gene's expression (composite).\n\n        Server-side chaining in ONE call: finds genes (transcript intervals,\n        with their TSS) in the sequence, then predicts expression off each\n        discovered TSS in the given experimental context. This is the right\n        tool whenever you want expression for a raw region or sequence — e.g.\n        \"find the genes in chr8:… and predict their expression in K562\".\n        predict_expression scores the sequence around ONE TSS and needs you to\n        know where that TSS is (a 9,198 bp window with the TSS at its\n        midpoint, or a longer sequence plus `tss_index`); this tool discovers\n        every gene's TSS itself. It has no 9,198 bp floor and no tss_index;\n        it starts with gene finding, so it takes 1,000–500,000 bp.\n\n        Runs async internally at every size (the annotate stage is slow even\n        for small inputs), so progress always streams. With wait=True\n        (default), blocks and streams progress, then returns the result\n        {data, meta} — it never returns a job_id on this path. With wait=False\n        (detached), returns {data: {job_id, status: 'submitted'}} immediately —\n        poll it with get_job. Because it ends in expression, `description`\n        (cell type / assay context) is REQUIRED.\n        ",
      "inputSchema": {
        "properties": {
          "description": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "REQUIRED experimental context — cell type / assay / conditions (e.g. 'K562 cell line'), applied to every found gene. The workflow ends in expression, which the API rejects without it.",
            "title": "Description"
          },
          "sequence": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "DNA bases, 1,000-500,000 bp (line breaks ignored). Mutually exclusive with sequence_ref.",
            "title": "Sequence"
          },
          "sequence_name": {
            "default": "sequence",
            "description": "Label echoed back.",
            "title": "Sequence Name",
            "type": "string"
          },
          "sequence_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Stored sequence handle. Mutually exclusive with sequence.",
            "title": "Sequence Ref"
          },
          "wait": {
            "default": true,
            "description": "Default True: block and stream progress until the result is ready. Set False for detached mode — returns a job_id immediately to poll with get_job.",
            "title": "Wait",
            "type": "boolean"
          }
        },
        "title": "find_genes_and_predict_expressionArguments",
        "type": "object"
      },
      "name": "find_genes_and_predict_expression",
      "outputSchema": {
        "additionalProperties": true,
        "title": "find_genes_and_predict_expressionDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Poll an async job once.\n\n        Returns the {data, meta} result if complete, a progress envelope\n        if still running, or an error envelope if it failed.\n        ",
      "inputSchema": {
        "properties": {
          "job_id": {
            "description": "Job id from an async tool (find_genes, find_genes_and_predict_expression).",
            "title": "Job Id",
            "type": "string"
          }
        },
        "required": [
          "job_id"
        ],
        "title": "get_jobArguments",
        "type": "object"
      },
      "name": "get_job",
      "outputSchema": {
        "additionalProperties": true,
        "title": "get_jobDictOutput",
        "type": "object"
      }
    },
    {
      "description": "List the caller's recent async jobs (also available as gi://jobs/recent).",
      "inputSchema": {
        "properties": {
          "limit": {
            "default": 20,
            "description": "Max number of recent jobs to return.",
            "maximum": 100,
            "minimum": 1,
            "title": "Limit",
            "type": "integer"
          }
        },
        "title": "list_jobsArguments",
        "type": "object"
      },
      "name": "list_jobs",
      "outputSchema": {
        "additionalProperties": true,
        "title": "list_jobsDictOutput",
        "type": "object"
      }
    },
    {
      "description": "List available models for a task.\n\n        Use to discover model ids before passing one as the `model`\n        argument to a predict tool. The same catalog is also available\n        as the resource `gi://models`.\n\n        Returns a FLAT object — {task, default_model, models: [...]} — not the\n        {data, meta} envelope the predict tools return. Each model carries a\n        `bio_spec`, whose useful fields are `request_max_bp` (the enforced\n        ceiling, 500,000 everywhere) and `context_window_bp` (what the model\n        reads in one step — compare your sequence length against it: a shorter\n        one is scored against a padded window). `trained_window_bp` is the fixed\n        receptive field where there is no sliding window (null for a model\n        without one). For expression, `recommended_flank_bp` is how many bp the\n        model reads on each side of the TSS; longer TSS-centred input is\n        better, and fetch_gene_for_expression already fetches the largest\n        listed value. `request_max_bp` is the only cap; the other\n        fields describe what the model reads, not what the route accepts.\n        ",
      "inputSchema": {
        "properties": {
          "task": {
            "description": "Task name. One of: promoter, splice, enhancer, chromatin, expression, annotation.",
            "title": "Task",
            "type": "string"
          }
        },
        "required": [
          "task"
        ],
        "title": "list_modelsArguments",
        "type": "object"
      },
      "name": "list_models",
      "outputSchema": {
        "additionalProperties": true,
        "title": "list_modelsDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Load a bundled demo reference sequence and return a handle.\n\n        The server ships one curated, task-correct positive control per task\n        (list them via the gi://sequences resource) — e.g.\n        `expression_hbb_k562` is a ready-to-use K562 expression window for\n        predict_expression. Stores the demo and returns a handle to pass to a\n        predict_* tool: no Ensembl fetch, no quota. Handy for smoke-testing a\n        prediction end-to-end.\n        ",
      "inputSchema": {
        "properties": {
          "name": {
            "description": "Demo name from gi://sequences, e.g. 'expression_hbb_k562', 'promoter_tp53', or 'annotation_hbb_chr11'. A gene token like 'TP53' also resolves.",
            "title": "Name",
            "type": "string"
          }
        },
        "required": [
          "name"
        ],
        "title": "load_demo_sequenceArguments",
        "type": "object"
      },
      "name": "load_demo_sequence",
      "outputSchema": {
        "additionalProperties": true,
        "title": "load_demo_sequenceDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Chromatin annotation across 919 features (G0 DeepSEA). 200–500,000 bp.\n\n        The model reads a 1,000 bp context window; 200–999 bp is accepted and\n        scored against a padded window.\n        ",
      "inputSchema": {
        "properties": {
          "model": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional model id; omit for the task default. See list_models.",
            "title": "Model"
          },
          "sequence": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "DNA bases A/C/G/T/N (case-insensitive). Line breaks are ignored (a wrapped FASTA body may be pasted verbatim; a `>` header line may not). Mutually exclusive with `sequence_ref`.",
            "title": "Sequence"
          },
          "sequence_name": {
            "default": "sequence",
            "description": "Label echoed back in the response (ignored when `sequence_ref` is used).",
            "title": "Sequence Name",
            "type": "string"
          },
          "sequence_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Handle (seq_…) from any acquisition tool (fetch_ensembl_sequence, fetch_region, fetch_gene_for_expression, load_demo_sequence, load_local_fasta, store_inline_sequence). Mutually exclusive with `sequence`.",
            "title": "Sequence Ref"
          }
        },
        "title": "predict_chromatinArguments",
        "type": "object"
      },
      "name": "predict_chromatin",
      "outputSchema": {
        "additionalProperties": true,
        "title": "predict_chromatinDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Predict enhancer activity (G0 DeepSTARR). 50–500,000 bp.\n\n        50 bp is the task's admission floor (the API 422s below it), not a\n        statement about what the model reads: enhancer models score a 249 bp\n        context window, so 50–248 bp is accepted and scored against a padded\n        window. For a meaningful call, submit at least the 249 bp context.\n        ",
      "inputSchema": {
        "properties": {
          "model": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional model id; omit for the task default. See list_models.",
            "title": "Model"
          },
          "sequence": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "DNA bases A/C/G/T/N (case-insensitive). Line breaks are ignored (a wrapped FASTA body may be pasted verbatim; a `>` header line may not). Mutually exclusive with `sequence_ref`.",
            "title": "Sequence"
          },
          "sequence_name": {
            "default": "sequence",
            "description": "Label echoed back in the response (ignored when `sequence_ref` is used).",
            "title": "Sequence Name",
            "type": "string"
          },
          "sequence_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Handle (seq_…) from any acquisition tool (fetch_ensembl_sequence, fetch_region, fetch_gene_for_expression, load_demo_sequence, load_local_fasta, store_inline_sequence). Mutually exclusive with `sequence`.",
            "title": "Sequence Ref"
          }
        },
        "title": "predict_enhancerArguments",
        "type": "object"
      },
      "name": "predict_enhancer",
      "outputSchema": {
        "additionalProperties": true,
        "title": "predict_enhancerDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Predict a gene's expression from the sequence around its TSS.\n\n        Expression is cell-type-specific, so `description` (cell type /\n        assay context, e.g. 'K562 cell line') is REQUIRED — the API\n        rejects requests without it.\n\n        The input rule is the same for every expression model: at least\n        9,198 bp, with the TSS at least 4,599 bp from each end, up to\n        500,000 bp. Longer TSS-centred sequence gives better predictions:\n        each model's bio_spec.recommended_flank_bp (see list_models) says how\n        many bp it reads on each side of the TSS, and flank beyond that is\n        ignored. Less flank, down to 4,599 bp, is accepted and scored, but\n        the model then reads less than it was trained on. Omit `model` for\n        the server's default.\n\n        - A 9,198 bp sequence with the TSS at offset 4,599 (the midpoint)\n          needs no `tss_index`.\n        - Any longer sequence needs `tss_index`: the 0-based offset of the\n          TSS into it (a fetch_gene_for_expression handle carries its own).\n          The API cuts what the model reads around that offset and never\n          scans for a TSS itself.\n\n        Under 9,198 bp, or a TSS closer than 4,599 bp to either end, is\n        rejected here and by the API (422). A locus with no offset is\n        rejected too, because it is indistinguishable from a mis-centred\n        window. A very N-rich or low-complexity window can also be refused\n        by the API (422).\n\n        An offset that is merely WRONG (e.g. counted over a wrapped FASTA's\n        characters, or against a chromosome coordinate instead of an offset\n        into THIS sequence) still succeeds and scores the wrong window —\n        verify meta.task_specific_counts.scored_window in the response.\n\n        Easiest paths: fetch_gene_for_expression(gene) already fetches a\n        long TSS-centred handle (as much flank as the listed models\n        recommend) and records its `tss_index`, which is sent for you when\n        you pass that handle without one; find_genes_and_predict_expression\n        takes a raw region and finds each TSS for you.\n        ",
      "inputSchema": {
        "properties": {
          "description": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "REQUIRED experimental context — cell type / assay / conditions (e.g. 'K562 cell line', 'liver tissue'). Expression is cell-type-specific; the API rejects requests without it.",
            "title": "Description"
          },
          "model": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional model id; omit for the task default. See list_models.",
            "title": "Model"
          },
          "sequence": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "DNA bases A/C/G/T/N (case-insensitive). Line breaks are ignored (a wrapped FASTA body may be pasted verbatim; a `>` header line may not). Mutually exclusive with `sequence_ref`.",
            "title": "Sequence"
          },
          "sequence_name": {
            "default": "sequence",
            "description": "Label echoed back in the response (ignored when `sequence_ref` is used).",
            "title": "Sequence Name",
            "type": "string"
          },
          "sequence_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Handle (seq_…) from any acquisition tool (fetch_ensembl_sequence, fetch_region, fetch_gene_for_expression, load_demo_sequence, load_local_fasta, store_inline_sequence). Mutually exclusive with `sequence`.",
            "title": "Sequence Ref"
          },
          "tss_index": {
            "anyOf": [
              {
                "minimum": 0,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "0-based offset of the transcription start site into the sequence, counted in bases (whitespace is ignored). Required unless the sequence is exactly 9,198 bp; must leave at least 4,599 bp on each side (4,599 <= tss_index <= length - 4,599). The model reads the sequence around this offset (9,198 bp for g0-expression, more flank for a model with a larger bio_spec.recommended_flank_bp) and the API reports the slice it used as meta.task_specific_counts.scored_window. Check it: a wrong-but-in-range offset scores the wrong window silently.",
            "title": "Tss Index"
          }
        },
        "title": "predict_expressionArguments",
        "type": "object"
      },
      "name": "predict_expression",
      "outputSchema": {
        "additionalProperties": true,
        "title": "predict_expressionDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Predict promoter regions (G0). 300–500,000 bp.\n\n        Returns the {data, meta} envelope: data.regions lists predicted\n        promoters with start/end/score.\n\n        300 bp is the task floor for every promoter model. The default\n        g0-promoter-2000bp scans a 2,000 bp context window, so a shorter\n        (but ≥300 bp) sequence is still scored — against a window padded out\n        to that size. Check the chosen model's bio_spec.context_window_bp via\n        list_models to know whether it saw real sequence or padding.\n        ",
      "inputSchema": {
        "properties": {
          "model": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional model id; omit for the task default. See list_models.",
            "title": "Model"
          },
          "sequence": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "DNA bases A/C/G/T/N (case-insensitive). Line breaks are ignored (a wrapped FASTA body may be pasted verbatim; a `>` header line may not). Mutually exclusive with `sequence_ref`.",
            "title": "Sequence"
          },
          "sequence_name": {
            "default": "sequence",
            "description": "Label echoed back in the response (ignored when `sequence_ref` is used).",
            "title": "Sequence Name",
            "type": "string"
          },
          "sequence_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Handle (seq_…) from any acquisition tool (fetch_ensembl_sequence, fetch_region, fetch_gene_for_expression, load_demo_sequence, load_local_fasta, store_inline_sequence). Mutually exclusive with `sequence`.",
            "title": "Sequence Ref"
          }
        },
        "title": "predict_promoterArguments",
        "type": "object"
      },
      "name": "predict_promoter",
      "outputSchema": {
        "additionalProperties": true,
        "title": "predict_promoterDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Predict splice donor/acceptor sites (G0 BigBird). 100–500,000 bp.\n\n        The model reads a 15,000 bp context window, so anything shorter is\n        scored against a padded window — feed a whole transcript locus when you\n        can. It is also strand-specific, and the wrong strand fails silently and\n        plausibly — it returns sites at different positions, often still scoring\n        above 0.9, not the near-zero scores once documented here. Nothing in the\n        response flags it, so submit the transcript's own orientation\n        (fetch_region takes `strand`).\n        ",
      "inputSchema": {
        "properties": {
          "model": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional model id; omit for the task default. See list_models.",
            "title": "Model"
          },
          "sequence": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "DNA bases A/C/G/T/N (case-insensitive). Line breaks are ignored (a wrapped FASTA body may be pasted verbatim; a `>` header line may not). Mutually exclusive with `sequence_ref`.",
            "title": "Sequence"
          },
          "sequence_name": {
            "default": "sequence",
            "description": "Label echoed back in the response (ignored when `sequence_ref` is used).",
            "title": "Sequence Name",
            "type": "string"
          },
          "sequence_ref": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Handle (seq_…) from any acquisition tool (fetch_ensembl_sequence, fetch_region, fetch_gene_for_expression, load_demo_sequence, load_local_fasta, store_inline_sequence). Mutually exclusive with `sequence`.",
            "title": "Sequence Ref"
          }
        },
        "title": "predict_spliceArguments",
        "type": "object"
      },
      "name": "predict_splice",
      "outputSchema": {
        "additionalProperties": true,
        "title": "predict_spliceDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Store a human-pasted sequence and return a handle to re-use it.\n\n        For a sequence you've already pasted into the conversation, this\n        gives back a short handle so you can run several tasks on it\n        without re-pasting the bases in each predict_* call. Note that the\n        full sequence still passes through the LLM on THIS call — it does\n        not save context on its own. For large sequences, prefer\n        fetch_ensembl_sequence / fetch_gene_for_expression / load_local_fasta,\n        which acquire the bases server-side and never round-trip them.\n\n        A line-wrapped FASTA *body* may be pasted verbatim: whitespace is\n        stripped before storing, so the handle's `length` counts bases and a\n        later `tss_index` counts into the same string the API measures. (A\n        FASTA `>` header line is not a sequence and is rejected by the API's\n        alphabet check.)\n        ",
      "inputSchema": {
        "properties": {
          "name": {
            "default": "sequence",
            "description": "Label for this sequence.",
            "title": "Name",
            "type": "string"
          },
          "sequence": {
            "description": "DNA bases to store and get a handle for. Line breaks are fine — whitespace is stripped, so the handle holds bases.",
            "title": "Sequence",
            "type": "string"
          }
        },
        "required": [
          "sequence"
        ],
        "title": "store_inline_sequenceArguments",
        "type": "object"
      },
      "name": "store_inline_sequence",
      "outputSchema": {
        "additionalProperties": true,
        "title": "store_inline_sequenceDictOutput",
        "type": "object"
      }
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:55a6427d0a76d50c3b1ef028563c4324c3a15f88fb2573a292680ea38d6c239f | sha256sum