MCP server

Jean — Molecular Biology & Genomics

io.github.genmnz/jean

Checked 26 Oct 2026, 08:29 UTC · Connected to it and listed its tools

Validated molecular biology tools: cloning, primers, CRISPR, Sanger, alignment, qPCR, phylogenetics

Website

At a glance

Type

MCP server

Publisher

Not verified

Status

Working at last check

Tools

308

Token cost

About 289,349 tokens per request

Sets up in

Claude Code, Claude Desktop, Codex, Gemini CLI, Cursor, VS Code, Antigravity, ChatGPT, OpenAI API, Grok

Last checked

26 Oct 2026, 08:29 UTC

Connect it to your agent

Add to CursorAdd to VS CodeVS Code Insiders

Opens the app, which shows the server and asks you to confirm. For other apps, copy the setup below.

Claude Code

claude mcp add --transport http jean https://jeanslabs.vercel.app/mcp

Claude Desktop

Settings → Connectors → Add custom connector, and paste the URL.

Codex (config.toml)

[mcp_servers.jean]
url = "https://jeanslabs.vercel.app/mcp"

Gemini CLI

{"mcpServers":{"jean":{"httpUrl":"https://jeanslabs.vercel.app/mcp"}}}

Cursor

{"mcpServers":{"jean":{"url":"https://jeanslabs.vercel.app/mcp"}}}

VS Code

{"servers":{"jean":{"type":"http","url":"https://jeanslabs.vercel.app/mcp"}}}

Antigravity

agy mcp add jean https://jeanslabs.vercel.app/mcp

ChatGPT

Settings → Apps & Connectors → Advanced settings: turn on Developer mode, then Create a connector and paste the URL. Which plans can do this varies.

OpenAI API (Responses tools)

{"type":"mcp","server_label":"jean","server_url":"https://jeanslabs.vercel.app/mcp","require_approval":"always"}

Grok (xAI API tools)

{"type":"mcp","server_label":"jean","server_url":"https://jeanslabs.vercel.app/mcp"}

Tools

• add_notebook_figure ~602 tokens
  Put a drawing that is on screen into the lab notebook as a numbered figure: a chart, gel, map or any other picture a tool drew on the stage. It is appended to the entry the user has open (or to the one you name), captioned with the drawing, the tool that drew it and what that tool concludes now, and
• align_read ~482 tokens
  Pairwise-align ONE sequencing read against a reference and hand on the two gapped rows, so the read can be graded. Needleman-Wunsch with free end gaps and the IUPAC substitution matrix — SeqTrace's aligner, the same call the trace editor makes, so a pipeline and the panel align a read identically. L
• align_sequences ~1839 tokens
  Multiple-sequence alignment over several sequences, under either of TWO engines that answer different questions and neither of which is a fallback for the other. `poa` (partial-order, poapy) aligns into a graph, keeps every path a read took and produces its own consensus row — what a pile of reads o
• analyze_melt_curves ~2532 tokens
  Melt curves to melting temperature, under any of THREE engines that answer different questions and none of which is a fallback for another. `plate` (RDML-Python) normalises, derives twice, calls the peaks of -dF/dT and CLASSIFIES them against the target's expected Tm into per-reaction verdicts — one
• antibody_antigen_contacts ~736 tokens
  Type the ANTIBODY-ANTIGEN INTERFACE of a deposited complex: which residue of each antibody chain touches which residue of the antigen, how close, and what kind of interaction each pair makes - ionic, polar, weak polar, hydrophobic, aromatic, carbonyl, or a disulfide. The antigen is found rather than
• antibody_canonical_classes ~669 tokens
  Assign each CDR of an antibody heavy, kappa or lambda variable domain to its canonical structure class: SCALOP's length-independent clusters of known loop conformations (CDR-H1, H2, L1, L2, L3; H3 has no canonical classes). Each loop is scored against every cluster of its length by the cluster's pos
• antibody_isotype ~586 tokens
  Name the CONSTANT region of an antibody chain: which immunoglobulin gene and allele it carries (IGHG1, IGHA2, IGKC, IGLC2 …), and where each IMGT domain sits on it — CH1, the hinge, CH2, CH3, the secretory tail and the membrane exons, or the single C region of a light chain. A domain search says 'a
• antibody_liabilities ~517 tokens
  Scan antibody and TCR variable domains for sequence liabilities (Asn deamidation, Asp isomerization, N-glycosylation sequons, Asp-Pro cleavage, Met and Trp oxidation, unpaired or missing conserved cysteines), each placed in its IMGT region so CDR hits can be told from framework ones. Every motif is
• antibody_molecule ~575 tokens
  Properties of an assembled antibody from its heavy and light chains: molecular weight, isoelectric point, net charge at a pH, and the extinction coefficient and A280 with cysteines reduced and with every pair formed into a cystine, for a Fab (1 heavy + 1 light) or an IgG (2 + 2). Each chain keeps it
• antibody_position_frequencies ~757 tokens
  How common each residue of an antibody variable domain is at its IMGT position, and which residues are rarer there than a cut (abYsis's 1% "unusual residue" by default). Two distributions: IMGT's own germline V and J alleles of a species (one count per reference allele), or a bundled Observed Antibo
• assemble_operon ~724 tokens
  Stack several CDSs into one contiguous operon, designing a fresh ribosome-binding site in front of each one AGAINST ITS REAL UPSTREAM CONTEXT — which is why the RBS for gene 2 is not the RBS design_rbs would give it in isolation. Returns the assembled sequence, its layout, and each gene's achieved s
• assembly_plan_simulate ~668 tokens
  Run a MULTI-LEVEL assembly plan (DnaCauldron `AssemblyPlan`): several assemblies arranged into dependency levels, where each level's products become parts for the next. Emits the FINAL construct as a record. The plan is DnaCauldron's own spreadsheet shape — one row per construct, `construct_name, pa
• audit_barcodes ~616 tokens
  Check an index set you ALREADY have, rather than designing a new one: the minimum distance between any two, how many errors that guarantees correcting, the full distance matrices, and — optionally — the subset that survives pruning to a stricter error budget. This is the question asked of a set inhe
• audit_cds_annotations ~552 tokens
  Check every annotated CDS of one or more GenBank maps against its own bases and genetic code: a frame that does not close (frameshift), a stop inside the reading frame, a first codon the code cannot start with, a last codon that is not a stop, and a /translation the bases do not give. A partial end
• bayesian_protein_inference ~1032 tokens
  Bayesian protein inference, Epifany (validated against OpenMS BayesianProteinInferenceAlgorithm on PXD000001): the posterior probability that each protein, each indistinguishable group and each peptide-spectrum match is present, from the matches' posterior error probabilities under a network in whic
• bootstrap_cq ~1352 tokens
  Resampling error bars on ONE reaction's Cq. A Cq is read off a fitted model, so its uncertainty is how tightly the observations pin that model down - which propagating a measured spread cannot answer. This refits the curve a few hundred times, either by resampling its residuals or by leaving observa
• build_ena_submission Changes files · ~940 tokens
  Turn a record into what ENA's Webin-CLI takes for an annotated sequence (`-context sequence`): an ENA flat file (`.embl`) and its manifest. Features are checked against the tables ENA's own validator reads, so what Webin-CLI would refuse (an unknown key, a missing mandatory qualifier, a double quote
• build_genbank_submission Changes files · ~1068 tokens
  Turn a record into the SUBMISSION SET NCBI's `table2asn` consumes: a `.fsa` whose defline carries the source modifiers, and a 5-column feature table (`.tbl`) beside it. This is not a GenBank export — GenBank's submission pipeline takes neither a `.gb` nor a plain fasta. Its real work is REFUSING and
• build_tree ~4557 tokens
  Build a phylogeny from aligned sequences — distance methods (NJ, BIONJ, FastME, UPGMA/WPGMA), parsimony, maximum likelihood, or Bayesian MCMC under a strict clock and coalescent prior — with branch support from a bootstrap, aLRT or aBayes, or, for the Bayesian method, clade posterior probabilities.
• calculate_power ~2154 tokens
  Power and sample size for a planned experiment: how many replicates a test needs to detect an effect, or what power, detectable effect or significance level a design that is already fixed gives. Leave ONE quantity out with `solve_for` and it is solved; everything else is given. Thirteen tests in two
• calculate_rnaseq_power ~925 tokens
  Sample size and power for an RNA-seq comparison of two groups, one gene at a time: the biological replicates per group needed to detect a fold change at a given sequencing depth and within-group coefficient of variation, or the power, detectable fold change, CV or α a fixed design gives. Leave one o
• call_cq ~1924 tokens
  Amplification curves to Cq, one row per reaction. Fits each raw fluorescence curve to a sigmoid (l4-l7, b4-b7), reads the Cq off it under any of the seven definitions (cpD1, cpD2, maxE, expR, Cy0, CQ, maxRatio) or at a fluorescence threshold you set (the classic Ct), and returns the per-reaction eff
• cancel_research_run ~536 tokens
  Withdraw a research run's pending hypotheses (all of them, or the ones named) so no resume runs them, and return the sealed run file. Nothing is deleted: a canceled hypothesis stays registered and still counts in e-BH with e 1, because it was registered before any result and dropping it would raise
• check_assay_decay ~864 tokens
  Check a published PCR or sequencing assay against the sequences that are circulating now: for each oligo, where its best binding site is in each genome, how many positions mismatch, and whether a mismatch sits in the 3′ end a polymerase has to extend through. It answers the question an assay's age r
• check_golden_gate_parts ~499 tokens
  Check parts BEFORE a Type-IIS assembly: how many recognition sites each carries, which of them are the two deliberate flanking sites and which are internal sites that will mis-cut the part. This is what answers “why will this assembly not work” — an internal site has to be domesticated (silently rec
• check_invariants ~892 tokens
  Decide whether a sequence is scientifically admissible: protein unchanged, forbidden restriction sites absent, reading frame intact, length/GC/CAI inside stated bounds. Every verdict names what broke, where, and the remedy. Run this after any design or optimisation step, and stop the chain when `adm
• check_manufacturability ~718 tokens
  Measure a sequence against what a NAMED synthesis vendor publishes it can make: length, average and windowed GC, homopolymer runs, tandem repeats, long repeats and hairpin-forming inverted repeats. Every threshold is the vendor's own, read from the vendor's own page with the date it was read, and ev
• check_methylation_block ~515 tokens
  Whether the host's own methylation blocks the given enzymes ON THIS PLASMID, from REBASE's methylation-sensitivity tables localised onto your sites. The other term of the same reaction question `find_star_sites` answers. It is deliberately per-SITE and not per-enzyme: REBASE says Dam blocks ClaI, an
• check_rows ~1015 tokens
  A QC gate over a TABLE: assert something about every row at once (every band inside a size window, no guide above an off-target score, at least three assays under a penalty). Fails the pipeline (so everything downstream skips) and names the rows that broke the rule.
• check_scorpion_stem ~1698 tokens
  A Scorpion probe's two melting temperatures, side by side: the stem-loop's own hairpin and the duplex the loop makes with its target on the amplicon. A Scorpion is a primer carrying a stem-loop probe on a non-amplifiable blocker (Whitcombe 1999), and it reports by the loop finding its target and pul
• check_value ~1100 tokens
  A QC gate. Compares a wired value against a threshold and PASSES or FAILS the pipeline there — every node downstream of a failed gate is skipped, so a run stops at the first check that does not hold. This is how a pipeline expresses 'only continue if the clone is right'.
• classify_droplets ~2421 tokens
  ddPCR droplet amplitudes to populations. For TWO targets, a four-way classification — NN, NP, PN, PP — under any of THREE published methods that answer different questions and none of which is a fallback for another. `grid` applies eight fixed thresholds: reproducible and auditable, the only one tha
• classify_grammar_part ~441 tokens
  Which Golden Braid / MoClo / Yeast ToolKit grammar, position and level the open plasmid represents (or null). Reads the record's own annotations, which is what lets an assembled transcription unit be recognised by its backbone half, and what lets a Level-0 module whose own backbone carries an extra
• codon_usage_analysis ~1012 tokens
  Codon-usage analysis of an in-frame CDS: CAI / expression stats, GC, and every rare-codon occurrence for the chosen organism (pydna port), plus the two bias measures that need NO reference table — ENC (Wright 1990) and RCBS (Roymondal 2009), which are therefore computable for any organism.
• codon_usage_distance ~588 tokens
  How this region's codon usage compares with the record's OTHER genes (CUFS, Diament, Pinter & Tuller 2014). Every other codon score grades one sequence against a reference TABLE; this one grades two sequences against each other, so it stays available for an organism no authority covers. Answers 'doe
• compare_antibodies ~708 tokens
  Several antibodies side by side: each record numbered by ANARCI, its heavy or its light variable domains aligned column by column by their numbering (a column is one scheme position, so nothing is re-aligned and an insertion is its own column), the CDR of every column under the chosen definition, ho
• compare_trees ~629 tokens
  Compare trees over the same taxa: the Robinson-Foulds distance between two of them, and the consensus of any number. Two methods disagreeing is a result about the data, so the distance and the shared topology are reported together.
• convert_mass_moles ~684 tokens
  Convert a mass of a molecule to an amount in moles and a number of molecules, or an amount back to a mass. The weight is the open record's own, computed from its sequence (both strands of a double-stranded record under its topology, a protein from its residues), or one you give.
• crispr_analyze_screen ~1106 tokens
  Call HITS from a pooled CRISPR screen: per-guide read counts in, a gene-level Bayes factor and a precision/recall curve out. This is the other end of a screen from the pool designer — it reads what came back rather than deciding what to order. The estimator is BAGEL2 (Kim & Hart 2021), reproduced by
• crispr_design_guides ~651 tokens
  Design and score CRISPR guides on the subject — on/off-target scores, QC flags, and cloning-enzyme conflicts. Nuclease list comes from the real nuclease registry.
• crispr_design_library ~1454 tokens
  Turn the open record's annotated targets into an ORDERABLE sgRNA oligo pool: the best N guides per target, filtered at order time (Pol-III terminator, Graf inactive motif, cloning-enzyme site, minimum on-target score), each composed into the oligo a synthesiser makes — the vector's cloning overhangs
• demultiplex_reads ~510 tokens
  Assign reads to the index each one came from, and say how many could NOT be assigned reliably — a hit further from a barcode than the set's guaranteed correction radius is not that barcode, and counting it as one is how a demultiplexing report hides a failed run.
• describe_discovery_corpus ~419 tokens
  The design step's view of a discovery corpus: each record's name, file, length and GC fraction, and how many records each file holds. Runs no test and returns no statistic, so hypotheses proposed from it are proposed before any result is seen (POPPER's metadata-only design step). Use it before run_d
• design_barcodes ~880 tokens
  Design a set of NGS sample-index barcodes with a guaranteed minimum distance, and report what that set actually corrects — substitutions, or indels too (DNABarcodes).
• design_bisulfite_primers ~1730 tokens
  Design BSP or MSP primers for a methylation assay, on the CONVERTED strands: after bisulfite treatment every unmethylated C reads as T, which is a different template from the one every other designer sees. BSP primers avoid CpGs so they amplify regardless of methylation state; MSP primers sit ON CpG
• design_codehop ~2134 tokens
  Design CODEHOP hybrid oligos from a block of aligned PROTEIN - for homologues too diverged for nucleotide-level design to see at all. Each primer is a 3' DEGENERATE core over a few conserved residues fused to a 5' non-degenerate consensus clamp, back-translated through a codon-usage table. A differe
• design_degenerate_primers ~1326 tokens
  Design degenerate primers from a multiple-sequence ALIGNMENT - the 'amplify every homologue in this family' question, which a single-template designer cannot answer because it only ever sees one sequence. A faithful port of DegePrime (Hugerth et al. 2014). Wire an upstream align_sequences `rows` out
• design_expression_variants ~1650 tokens
  The expression-design deliverable: several coding sequences for one protein, each variant following a different published strategy (maximise codon adaptation, match the host's codon usage, harmonise with the native host, or preserve the initiation region), each scored by an engine — CAI, GC, the fol
• design_fusion_site_primers ~652 tokens
  Design the PCR primers that ADD Type-IIS fusion sites to a part: enzyme site, spacer and the four-base overhang you chose, on a Tm-matched annealing footprint. This is how a sequence that is not yet a Golden Gate part becomes one, and it is the other half of check_golden_gate_parts — that says which
• design_genetic_circuit ~808 tokens
  Design a genetic circuit that computes: give it a logic function and it synthesizes a NOR/NOT netlist, assigns real characterized repressor gates from a Cello UCF library, predicts the dynamic range between ON and OFF, and emits the construct's DNA. The gate parameters are MEASURED, from the publish
• design_gibson_primers ~1588 tokens
  Design the PCR primers that CREATE the terminal homology a Gibson/NEBuilder/In-Fusion assembly needs: a Tm-matched pair per fragment, each carrying the 5' overhang that fuses it to its neighbour in the order given (pydna assembly_fragments). This is the step that turns a planned assembly into oligos
• design_hcr_probes ~1129 tokens
  Design HCR v3.0 split-initiator probe pairs against the subject: tile its reverse complement into 52 nt windows, drop windows with C or G runs, a stable hairpin, G+C or RNA:DNA free energy outside their windows, or (given a bowtie2 alignment of the tiles) more than one genome hit, then pick non-over
• design_ish_probes ~2112 tokens
  Design an in-situ hybridization probe against the subject: tile it into candidate oligos that meet a melting-temperature, G+C and composition specification, screen them for off-target binding against an alignment and for k-mers abundant in a reference, and gather the survivors into the set that imag
• design_knockout_package ~1508 tokens
  The complete build package for a knockout or knock-in, as one object: guides inside the target, an off-target census for the chosen one within this molecule, a repair template with real homology arms, a screening PCR whose primers sit OUTSIDE the arms, the protocol in order, the fragments and oligos
• design_lamp_primers ~1672 tokens
  Design LAMP (loop-mediated isothermal amplification) primer SETS - four core oligos (F3 · B3 · FIP · BIP) plus optional loop primers, judged against Eiken's own PrimerExplorer V5 criteria. Not a pair: LAMP needs six binding regions in the published order and the distances BETWEEN them are as much of
• design_merfish_probes ~1784 tokens
  Design MERFISH encoding probes for the subject transcript: tile it into target regions, keep those whose G+C and melting temperature fall in their windows, that share no k-mer with an rRNA or tRNA, and whose k-mers occur in this gene's transcripts and nowhere else in the transcriptome; attach readou
• design_multisite_primers ~2105 tokens
  Design QCLM (quick-change lightning multi-site) oligos: one primer per mutated site, all annealing in one reaction, with the codons drawn from an organism's usage table. A design/write.
• design_mutagenesis_primers ~826 tokens
  Design site-directed mutagenesis (SOE-PCR/QuikChange) primers for a point change on a CDS: the ranked inner mutagenic pairs, the constant outer pair, and the single spanning primer that replaces an outer when the site sits too near a CDS end. A design/write.
• design_oligo_plate_order Changes files · ~909 tokens
  Lay a set of oligos out as a supplier's PLATE order sheet: one worksheet per plate, in the well order the supplier's own order form fills, with the column shape its loading direction requires. A plate order is addressed BY WELL, which a flat tube list cannot express — so this is the shape an oligo s
• design_overhang_set ~915 tokens
  Design a high-fidelity Golden Gate overhang set of a given size against measured ligation data, optionally pinning junctions you cannot change (a fixed vector's own overhangs). The counterpart to score_overhang_fidelity: that grades a set you already have, this proposes one. The search is greedy-plu
• design_padlock_probes ~855 tokens
  Design padlock probes for in-situ sequencing against the subject: find the two-arm targets whose melting temperature falls in a window, check each against a BLAST search for any other transcript that could be ligated across the junction, pack non-overlapping targets from the 3' end, and assemble eac
• design_primers ~1355 tokens
  Design a forward + reverse primer pair to amplify the subject (pydna `primer_design`), with Tm, Ta and suggested Taq/Phusion cycling programs. Emits both primers so a downstream pcr_amplify runs on them — the design→PCR→gel loop.
• design_qpcr_assay ~2690 tokens
  Design qPCR assays over the subject — primer pair plus hydrolysis probe, ranked by penalty, with amplicon size/GC, per-oligo Tm and whether both primers bind a single site.
• design_rbs ~458 tokens
  Design a 5'UTR (Shine-Dalgarno + spacer) in front of a CDS to hit a target translation-initiation strength (SC-08 engine, Turner-2004 folding).
• design_saturation_primers ~2853 tokens
  Design site-saturation mutagenesis (SSM) primers: one overlapping forward/reverse pair per site, each carrying a degenerate codon, sharing ONE reaction-level overlap and 3' temperature so every site amplifies in the same tube (both of Mutation Maker's solvers: fast approximation by default, exhausti
• design_sequencing_primers ~928 tokens
  Design a WALK of sequencing primers that reads a whole region, not one pair: tiled reads with confirmed overlap, on both strands by default, plus the coverage the walk actually achieves and any stretch it cannot reach. This is the 'how do I read all 6 kb of this construct' question, which a single p
• design_split_sites ~1272 tokens
  Decide where to CUT one sequence into Golden Gate fragments, optimising the split positions and the overhangs they create together. Where design_overhang_set proposes junctions for parts you already have, this fragments a sequence you are about to order: it searches every legal arrangement of fragme
• design_xenium_probes ~1176 tokens
  Design Xenium custom-panel padlock targets on the subject transcript to 10x Genomics' published rules (CG000683): two 20 nt arms whose primer3 melting temperatures fall in their windows, a ligation-junction dinucleotide the Xenium ligase accepts, no run of five G in the probe, at least four mismatch
• differential_expression ~3140 tokens
  Differential expression from raw RNA-seq read counts, by one of the three standard count models. DESeq2 (Love, Huber & Anders 2014): median-of-ratios size factors, negative-binomial GLM with empirical-Bayes shrunken dispersions, Wald or likelihood-ratio test, Cook's-distance outlier handling, indepe
• digest_fragments ~476 tokens
  Digest the subject with the given enzymes into real fragments (sequence + both overhangs). Emits the selected fragment as a NEW record, so a downstream gel/map/ORF runs on that fragment — the digest→assembly hand-off.
• digest_reaction_conditions ~514 tokens
  The reaction a digest needs, from NEB's own data: the NEBuffer that serves every enzyme together (scored on the WORST enzyme's percent activity, a star-activity buffer disqualified at any percent), the incubation temperature(s), any cofactor that must be added (SAM or ATP), and each product's heat-i
• discover_annotation_contradictions ~1099 tokens
  Find the signal peptides or transmembrane segments in reviewed human UniProt that a sequence predictor contradicts. Each feature backed by experiment (evidence code ECO:0000269) is scored to say what a confirmed feature looks like to the predictor; every other feature, annotated from similarity, seq
• discover_codon_outliers ~1400 tokens
  Score every coding sequence of a genome against the genome's own codon usage and report the genes whose synonymous codon choice that average does not explain, with the false discovery rate controlled across the genes. Records from different files are different genomes: each is scored against its own
• discover_flag_rates ~1054 tokens
  Measure how often a corpus of maps carries a cryptic σ70 promoter, a cryptic splice site or a synthesis-breaking repeat MORE EXTREME THAN CHANCE, rather than how many it carries. Every map of a few kilobases spells promoters, splice donors and repeats, so a raw hit count measures length and composit
• discover_gene_tree_discordance ~1146 tokens
  Find the genes whose own alignment rejects the species tree. Each named alignment file is one gene, its records the taxa, named as the species tree's tips. For every gene the species tree and each of its nearest-neighbour rearrangements (two per internal branch) is fitted by maximum likelihood under
• discover_reference_concordance ~677 tokens
  Ask whether a reference-gene stability ranking holds across conditions, and which candidate genes rank well everywhere rather than in one tissue or treatment. Each condition (the Group column of a long-format Cq table) is ranked by geNorm on its own samples; the conditions are then the blocks of a F
• discover_reference_stability ~891 tokens
  Ask whether the genes used to normalize expression (reference or housekeeping genes, such as GAPDH, ACTB or B2M) are more or less variable across human tissues than genes of the same abundance, on GTEx v8 median expression. Each candidate's standard deviation of log2(TPM + pseudocount) across the ch
• discover_site_avoidance ~1173 tokens
  Sweep a set of sequences against every exact recognition site in the NEB catalog and report the sites each one carries far less (avoided) or far more (enriched) often than a stated null predicts, with the false discovery rate controlled across every (sequence, site) test. Avoidance is evidence of th
• discover_target_validation ~812 tokens
  Test a hypothesis that a gene drives a phenotype ("gene G regulates IL-2 production") the way POPPER does: each evidence table is one falsification test, an implication of the hypothesis that a gene-level score could contradict (expression in the relevant tissue, association with related disease, in
• discover_tree_incongruence ~949 tokens
  Ask whether some loci of a multi-locus alignment have a different history from the rest, by the incongruence length difference test (Farris et al. 1994). Each locus is one aligned FASTA file (or a set of wired alignment rows) over the same taxa, named alike in every file. D is the extra parsimony st
• domesticate_part ~765 tokens
  Silently recode the internal Type-IIS sites inside a part's coding sequence so the part can be used in a Golden Gate assembly — same protein, no recognition site. Only occurrences the given CDS covers can be fixed this way; any outside it are reported untouched rather than skipped quietly, because a
• dot_plot ~1326 tokens
  Self-similarity or pairwise comparison of the subject as a dot plot — repeats, inversions and shared regions. Three real engines: exact k-mer (FlexiDot/dottup), windowed identity (seqinr) and windowed substitution-matrix scoring (EMBOSS dotmatcher), which answer different questions.
• dot_plot_grid ~958 tokens
  All-against-all dot plot over a sequence SET — EMBOSS `polydot`. Every ordered pair is plotted with the exact k-mer engine and laid out as an N×N grid, so shared regions, repeats and inversions across a whole family are visible in one picture. Answers a different question from `dot_plot`, which comp
• draw_alignment ~862 tokens
  Draw a block of an alignment as an SVG figure: the rows named, the residues shaded by how much of their column agrees with them, the column numbers over the block and Easel's Clustal conservation line under it. Wire `alignedSequences` from align_sequences. Name the window around whatever you are ask
• draw_gel ~1371 tokens
  Run an agarose gel and photograph it: every lane's fragments migrated by the validated pydna model, drawn as a gel-doc image with the marker ladder's bp marks and each lane's name. The same plate the gel panels draw, so the figure and the rail put every fragment in the same place. Wire `fragments` f
• draw_tree ~964 tokens
  Draw a tree as an SVG figure — rectangular, slanted, circular or unrooted, as a phylogram or a cladogram, with tip names, branch support and a scale bar. The same layout the phylogeny panel draws with, so the figure and the panel place every node identically. Wire `newick` from build_tree or edit_tr
• enzyme_collection ~492 tokens
  Resolve one of your saved enzyme collections to the enzyme names in it, so a later step can scan, digest or design with 'my Golden Gate set' by name instead of whatever happens to be selected. Names the collection, says which of its enzymes the cut catalog can resolve and which it cannot, and — when
• enzyme_cut_counts ~395 tokens
  Per-enzyme cut counts on the open plasmid (the EcoRI² superscript-badge numbers).
• estimate_effect_size ~1120 tokens
  The effect a power calculation needs, measured from a pilot instead of guessed: two groups of one measurement in a table, standardized as Hedges' g (default), Cohen's d or Glass's Δ with its noncentral-t confidence interval (effectsize 1.0.3, reproduced), and the two-sample t design sized at the est
• export_barcodes ~794 tokens
  Write an index set out in the form the next step needs: a CSV or TSV order sheet, FASTA, an IDT bulk-input sheet of the bare tags, an Illumina BCLConvert SampleSheet, or the actual oligos — adapters built on a template, or primers carrying the tag — with the junction warnings that emission produces.
• export_map_svg ~1041 tokens
  Render the open record's map to a publication SVG string, circular or linear — the same figure the Export panel draws, with the same knobs and the same defaults. Give it enzymes to draw the restriction sites. The linear layout can draw both strands' bases and a window of the record (start/end), whic
• export_tree ~504 tokens
  Convert a tree between the four formats this workbench reads and writes — Newick, NEXUS, PhyloXML and NeXML — sniffing the input format rather than making the caller declare it. Newick loses annotations the richer formats carry, which is why the conversion is a step you choose rather than something
• fastq_qc ~848 tokens
  FastQC's report on FASTQ reads, every module a default FastQC run reports: per-base quality boxes, per-tile quality (when the headers carry a tile), per-sequence quality, per-base sequence content, per-sequence GC against FastQC's theoretical normal, per-base N content, sequence length distribution,
• filter_items ~742 tokens
  Keep only the rows of a table-shaped output that meet a condition — the bands above a size, the guides over a score, the assays under a penalty. Emits the kept rows plus how many were dropped, so a downstream gate can act on the count.
• find_orfs ~378 tokens
  Find open reading frames on BOTH strands of the subject (origin-spanning when circular).
• find_restriction_sites ~401 tokens
  Cut positions of the given enzymes on the open plasmid (top/bottom cut, overhang, kind).
• find_star_sites ~465 tokens
  Where the given enzymes could ALSO cut the open plasmid under non-standard conditions, from REBASE's own star-activity list and its one-base rule. Not cut sites: these need low ionic strength, high pH, Mn²⁺ for Mg²⁺, glycerol, DMSO or some detergents, and are what turns an over-digested reaction int
• fold_guide ~621 tokens
  Fold a guide RNA — the spacer alone, and the whole sgRNA on a real published scaffold — and report which bases of the spacer pair with the scaffold. A spacer that base-pairs into the scaffold disrupts the structure Cas9 binds, which is a physical cause of a dead guide rather than a score. Every free
• fold_rna ~339 tokens
  Minimum-free-energy secondary structure (dot-bracket + ΔG) of an RNA/DNA sequence (Turner-2004).
• fragment_ions ~572 tokens
  Theoretical MS/MS fragment ion ladder of a peptide: a, b, c from the N-terminus and x, y, z from the C-terminus, with neutral-loss and radical variants, at each charge up to a maximum (validated against pyteomics, cross-checked against OpenMS). Takes ProForma modification tags (a signed mass, a Unim
• fusion_pcr ~479 tokens
  Overlap-extension (fusion) PCR — join fragments that share terminal homology into one product, carrying their features across (pydna). Emits the fused product as a NEW record.
• gate_droplets ~1334 tokens
  Two-channel ddPCR droplet-amplitude exports to a template concentration, by CLASSIFYING the raw droplets rather than trusting a count the instrument already made. Four steps in a fixed order, each of which needs the previous one's output: a k-means quality check marks wells whose two droplet cluster
• gc_content ~350 tokens
  GC fraction of the subject — whole-sequence, or a sliding window profile (DnaChisel).
• gene_set_camera ~1514 tokens
  Competitive gene set test that accounts for inter-gene correlation (camera; Wu & Smyth 2012), as limma 3.68.5 runs it: is a set more differentially expressed than the genes outside it, with the variance of its mean statistic inflated by the correlation between its genes instead of treating them as i
• gene_set_enrichment ~1682 tokens
  Preranked gene set enrichment analysis (GSEA; Subramanian et al. 2005) with fgsea's multilevel p-values (Korotkevich et al.), either as clusterProfiler's GSEA() runs it (enrichit 0.2.6, with q-values; or its fixed-count or adaptive sample and permute tests) or as fgsea 1.38 itself runs it (fgseaMult
• gene_set_overrepresentation ~1004 tokens
  Over-representation analysis (ORA): which gene sets hold more of a gene list than chance, by the one-sided hypergeometric test against a background, as clusterProfiler's enricher() runs it (enrichit 0.2.6). Reports gene and background ratios, fold enrichment, odds ratio, z-score, p, adjusted p and S
• genotype_pca ~986 tokens
  Principal components of a call set's genotypes, the population-structure picture: biallelic sites above a minor-allele count, LD-pruned by sliding windows, scaled per site (Patterson, standard or centring) and decomposed; every sample's coordinates with its population, and the variance each componen
• get_open_record ~337 tokens
  Return the plasmid/sequence currently open in the editor. Emits it as a `record`, so it is the SOURCE node of a pipeline — wire its record into any downstream node's $subject.
• get_selection ~454 tokens
  The region selected on the canvas, as its own record. This is what makes a highlighted stretch a pipeline INPUT: wire its record into any node's subject and that step runs on the selection rather than on the whole molecule.
• gibson_assemble ~864 tokens
  Assemble fragments by terminal homology (Gibson / NEBuilder / In-Fusion, DnaCauldron). Emits the first product as a NEW record for downstream nodes.
• golden_gate_assemble ~682 tokens
  Assemble parts with a Type-IIS enzyme (Golden Gate / MoClo, DnaCauldron). Emits the first construct as a NEW record for downstream nodes.
• graft_antibody_cdrs ~744 tokens
  Humanize an antibody variable domain by CDR grafting: find the closest human germline V and J, merge them into an acceptor framework, and put the parental CDRs onto it. The classical humanization route, and the counterpart to humanize_antibody's language model. Reproduces abnumber 0.4.4 over every a
• history_protocol ~331 tokens
  Render a construct's build history into a numbered bench-recipe protocol.
• humanize_antibody ~702 tokens
  Humanize an antibody variable domain with Sapiens, the antibody language model behind BioPhi: score every position against human repertoires, take the highest-scoring residue in the frameworks, and keep the parental CDRs (and optionally the Kabat Vernier zone). Reports every mutation, and what the m
• infer_proteins ~1196 tokens
  Protein inference from peptide-spectrum matches (validated against OpenMS BasicProteinInferenceAlgorithm on PXD000001): maps each peptide to the protein database, keeps the best match per spectrum, scores each protein by aggregating its peptides' best scores, reports the proteins its evidence cannot
• isotope_envelope ~519 tokens
  Coarse isotope pattern of a peptide or of an elemental formula (C29H31N7O, as a compound's formula reads): the relative heights and masses of its M, M+1, M+2 … peaks as an instrument that does not resolve isotopic fine structure sees them, computed by per-element convolution from natural abundances
• isotopic_composition ~377 tokens
  The most probable isotopic composition of a peptide (e.g. how many 13C atoms it most likely carries) and that composition's relative abundance, from natural isotope abundances (validated against pyteomics).
• ligate_fragments ~938 tokens
  Ligate fragments by their overhangs (pydna ligation_assembly) — sticky, optionally blunt. Each input may be digested by its own enzymes first, which is the digest → ligate hand-off. Emits the first product as a NEW record.
• linkage_disequilibrium ~975 tokens
  Linkage disequilibrium between every pair of biallelic sites of a call set: the dosage correlation r of Rogers and Huff (scikit-allel), or haplotype r² and D′ from the maximum-likelihood two-locus haplotype frequencies (PLINK 1.9 --r2 dprime-signed), plus LD pruning by sliding windows (scikit-allel
• list_experiments ~497 tokens
  Your lab-notebook entries, newest first — id, title, tags, collection, when they changed, and the @plasmid / !action / &gel cross-references each one names. Filter by a tag, by collection, or by text in the title and body, so a run can find the entry it is continuing instead of starting a second one
• list_library ~390 tokens
  List the project's sequence documents (id, name, length, topology, kind).
• list_research_runs ~490 tokens
  List research runs without running anything: the runs this project holds (in the app), or the run files given (`runs`, which is how an HTTP or MCP caller lists the files it kept). For each run: whether its seal holds, its id, how many hypotheses it registered and how many are supported, not supporte
• list_sgrna_scaffolds ~348 tokens
  Every sgRNA scaffold this workbench has sourced, with the nucleases each covers and the publication it comes from. A scaffold not listed here is one we do not have — the list is what we ship, not what exists.
• list_workflow_templates ~134 tokens
  The built-in starter workflows — id, name, what each does and which tools it chains. Pass an `id` to get that template’s graph back, ready to hand to `run_workflow`. This server is stateless, so these are the shipped templates only, not anything a person has saved in their own editor.
• load_record ~392 tokens
  Read a CHOSEN project document as a record — the pipeline's data-reader source, for running on a specific file instead of whatever happens to be open in the editor. Wire its `record` into any downstream node's $subject.
• map_reads ~5457 tokens
  Map sequencing reads (FASTQ or FASTA) or assembled contigs onto a reference and return the alignment as SAM, the file a pileup viewer, a variant caller or `samtools` reads next. This is minimap2 (minimizer seeds, chaining, banded dual-affine extension with inversion detection, MAPQ), ported and chec
• melt_profile ~601 tokens
  DNA melting behaviour of the subject by the Poland–Scheraga model (DECIPHER): the melt curve (mean helicity vs temperature), its Tm50, and the cooperatively-melting domains behind each HRM peak.
• miqe_checklist ~544 tokens
  The MIQE 2.0 checklist for a qPCR paper (Bustin et al. 2025, Clin Chem 71:634, Table 1): every item in its five sections, with your answers. Each answer is Provided (yes or no) and Description/Justification: where in the article when yes, why it is omitted when no; an answer missing that is named. R
• multiplex_pcr ~1876 tokens
  Screen a primer POOL against one or more templates: every predicted product, per-primer off-target binding, the pairs that tell templates apart on a gel, and the all-against-all primer-dimer matrix a pool actually lives or dies by (pydna primer_screen + primer3 thal).
• notebook_cross_refs ~342 tokens
  Extract @plasmid / !action / &gel cross-references from a lab-notebook markdown body.
• number_antibody ~812 tokens
  Find antibody and T-cell-receptor variable domains in a protein sequence, number them under IMGT, Kabat, Chothia, Martin, AHo or Wolfguy, call chain type and species, and assign the closest V and J germline with percent identity. Validated against ANARCI 2026.2.13.2 on every chain of its PDB benchma
• optimize_sequence ~902 tokens
  Run the DnaChisel optimizer over the subject with real constraints/objectives (GC window, pattern avoidance, translation enforcement, …). Emits the optimized sequence as a NEW record for downstream nodes.
• pcr_amplify ~1256 tokens
  Amplify the subject template with a forward + reverse primer (pydna Anneal). Emits the first product as a NEW sequence record so downstream tools (digest, gel, map) operate on the amplicon, not the template — the tool→tool hand-off.
• peptide_mass ~603 tokens
  Monoisotopic and average mass of a peptide, and its m/z at each charge state (validated against pyteomics). Plain one-letter sequences also take an ion type (b, y, c, z, a, x and their neutral-loss forms); a ProForma peptidoform with modification tags, as masses or Unimod names and accessions (e.g.
• pick_first ~462 tokens
  Rejoin two branches: takes the outputs of several conditional steps and emits the first one that actually ran. This is how a two-way branch comes back together: wire both arms in, and whichever arm ran is what continues.
• plan_master_mix ~1798 tokens
  Scale one PCR reaction into a master mix for N reactions plus overage. Starts from a vendor's own published reaction setup (scaled to any reaction volume in proportion to the vendor's columns, so every final concentration is the vendor's, with water making up the volume and the template added per tu
• plan_next_tools ~758 tokens
  What can run next, and what each next step would add. Give it a tool whose run just finished (or the output types in hand) and it returns the tools whose own declared inputs those outputs fill, each with the parameter the wire lands on, the question that tool answers, its limits, what grades it, whe
• plan_rnaseq_experiment ~1532 tokens
  How many biological replicates an RNA-seq experiment needs when the question is about the WHOLE experiment rather than one gene: the exact negative-binomial test with the per-gene α derived from a target false discovery rate across m genes of which m1 are expected to move (RnaSeqSampleSize 2.23.0, Z
• plan_serial_dilution ~620 tokens
  Plan a serial dilution: the same fold dilution repeated tube after tube from a stock, each tube made to one volume. Returns the transfer and diluent volumes for every step, each tube's concentration and cumulative dilution, and what each tube holds after giving its transfer to the next.
• population_ancestry ~996 tokens
  Individual ancestry coefficients, the ADMIXTURE-style picture: each sample as a mixture of K ancestral populations, fitted by sparse non-negative matrix factorisation for every K in a range, with K scored by the cross-entropy of predicting genotypes held out at random (LEA snmf, Frichot et al. 2014)
• population_fst ~759 tokens
  Differentiation between populations of a call set: Weir and Cockerham's θ over two or more populations, or Hudson's or Patterson's Fst between pairs, per site and averaged with a block-jackknife standard error (scikit-allel). Every pair when more than two populations are compared. Validated on every
• population_site_stats ~601 tokens
  Per-site and per-sample genotype statistics of a call set, for all samples or one population: allele counts and frequencies, called and missing calls, heterozygous and homozygous counts, observed and expected heterozygosity and the inbreeding coefficient F (scikit-allel), and the exact Hardy–Weinber
• primer_check ~756 tokens
  Where a primer anneals on the open plasmid: 3'-anchored sites with identity % and the ✓/⚠/~/✗ verdict, graded at a bar you can move and that the answer states. The scan is 3'-anchored, so every site it reports matches the oligo's 3' seed exactly and 'no sites' means no seed match rather than a low s
• propagate_uncertainty ~1415 tokens
  Uncertainty through any qPCR quantity, three independent ways at once. Give it the expression you actually report - a ratio, a normalised expression, an efficiency-corrected quantity - and a mean and standard deviation for each variable in it (or the replicate observations themselves), and it return
• protein_digest ~2180 tokens
  In-silico proteolytic digest of a protein (ExPASy PeptideCutter / PeptideMass): peptides with coordinates, average and monoisotopic masses, m/z per charge state, and the MS mass-window filter. 49 proteases and chemicals — or an enzyme of your own written in RPG rule grammar — one or several at a tim
• protein_disorder ~1010 tokens
  Intrinsic disorder along a protein by FoldIndex (Prilusky 2005): I_F = 2.785·⟨H⟩ − |⟨R⟩| − 1.151 over a sliding window, where ⟨H⟩ is mean normalized Kyte-Doolittle hydropathy and ⟨R⟩ the mean net charge per residue. Negative means predicted unfolded. Reports the whole-protein score, the per-window s
• protein_disorder_metapredict ~815 tokens
  Per-residue intrinsic disorder by metapredict (Emenecker, Griffith & Holehouse, Biophys J 2021; V2/V3 the lab's successors), a bidirectional LSTM trained to reproduce a consensus of disorder predictors, run locally. Reports a 0–1 score per residue, the IDRs and folded domains its domain caller draws
• protein_membrane_profile ~528 tokens
  Eisenberg hydrophobic-moment plot along a protein: per-window mean hydrophobicity and moment, each classified Globular / Transmembrane / Surface-seeking, plus those windows collapsed into residue spans. A hydrophobicity-based prediction, NOT a trained topology model.
• protein_profile ~2536 tokens
  Windowed physicochemical profile along a protein (ExPASy ProtScale). Pass `scaleId` for any of the 57 scales ProtScale publishes plus the 14 Biopython tables it does not, with optional 0-1 normalisation; or pass `kind` for the five ProtParam profiles (hydropathy over the 28 GRAVY scales, Vihinen fle
• protein_properties ~1050 tokens
  Molecular weight (average + monoisotopic), molecular formula, isoelectric point, instability index and amphipathicity (Boman index, Eisenberg hydrophobic moment) of a protein sequence (Biopython ProtParam + `peptides` + `pyteomics`).
• protein_signal_peptide ~604 tokens
  Signal-peptidase cleavage sites in a protein, by von Heijne's (1986) weight matrix as implemented by EMBOSS sigcleave. Scores a 15-residue window at every position (the 13 residues before the cut plus the first two after) against either the eukaryotic or the prokaryotic training set. Predicts WHERE
• protein_topology ~559 tokens
  Transmembrane topology of a protein by the HMM-TM 114-state hidden Markov model (JUCHMME, Bagos et al.), decoded residue by residue into inside / transmembrane-helix / outside runs. Reports the labelled path, the runs as residue spans, and the per-residue posterior. Needs the trained model, which th
• quantify_dpcr ~1624 tokens
  Digital PCR (dPCR) partition counts to absolute concentration, with no standard curve. Positives and accepted partitions become lambda = -ln(1 - k/n), lambda becomes copies per uL through the partition volume and the dilution chain, and the confidence interval is carried on the lambda scale under an
• rank_next_tests ~1045 tokens
  Rank candidate experiments by what running them would TEACH — Lindley's expected information gain, the drop in uncertainty about a hypothesis expected before anything is run. Three grains: `tests` ranks candidate falsification tests against the beliefs a discovery ledger holds, each with the posteri
• rank_reference_genes ~679 tokens
  Which candidate reference gene is actually stable, ranked by all four published algorithms at once plus the RefFinder consensus: geNorm (pairwise variation M), NormFinder (intra/inter-group variance), BestKeeper (SD of raw Cq and correlation to the index) and the comparative delta-Ct method. They di
• rank_strategies ~882 tokens
  Compare EVERY assembly chemistry this engine has against one set of parts, and say what each one costs and risks. It runs them all, keeps the ones that really produce a construct, and reports the rest with the refusal the chemistry itself gave — so 'Golden Gate is the only way to build this, and its
• rank_tradeoffs ~1014 tokens
  Which candidates in a table are not beaten on every objective at once: Pareto (non-dominated) sorting of rows scored on several columns, each to maximize or minimize. Returns each candidate's front (1 = non-dominated), the candidate one front up that beats it, and its crowding distance within its fr
• read_mgf ~435 tokens
  Read the MS/MS spectra of a Mascot Generic Format (MGF) file: each spectrum's title, precursor m/z, precursor intensity, declared charge states and peak list, interpreted as pyteomics reads MGF (validated on every spectrum of PXD000001). A spectrum it returns is what score_spectrum takes as mz, inte
• read_mzml ~496 tokens
  Read the spectra of a PSI mzML run file: each spectrum's native id, MS level, centroid or profile, scan start time and unit, base peak, total ion current, precursor (selected ion m/z, charge, intensity, isolation window) and peak arrays, interpreted as pyteomics reads mzML (validated on every spectr
• read_rdml_run ~792 tokens
  Read an instrument's RDML export - the open qPCR exchange standard, v1.0 to v1.4 - and hand back one run's contents as the same tables every other qPCR tool here takes. This is the step every qPCR analysis starts from. Lists what each run actually holds (amplification curves, melting curves, instrum
• read_sequencing_qc ~835 tokens
  Read the QC files a sequencing provider returns alongside the reads: a per-base COVERAGE table, or a Plasmidsaurus summary (k-mer composition and the contamination estimate with its named source). These are the numbers that say whether a disappointing read is the clone's fault or the run's — a base
• read_structure ~676 tokens
  Read a structure file — PDB, PDBx/mmCIF, or a core CIF small-molecule crystal structure — and report what is in it: the chains and what kind each is, their sequences, the ligands and ordered solvent, the disulfides, the residues the depositor declared modified, the temperature-factor range, the unit
• read_structure_consensus ~586 tokens
  Read the consensus RNA secondary structure a Stockholm alignment states in its `#=GC SS_cons` line (WUSS, the notation Rfam and Infernal write), and measure how well the aligned rows actually support it. Reports the base pairs, what each unpaired column is (hairpin, bulge, multifurcation, external,
• recombine ~961 tokens
  Recombination between molecules — Gateway BP/LR (att sites), Cre/loxP, a serine integrase whose two half-sites you supply, plain homologous recombination through shared arms, or a CRISPR knock-in that keeps only products whose repair region contains every guide's cut. Emits the first product as a NE
• record_composition ~518 tokens
  What the subject record is MADE OF: molecular weight under its own topology and strand count, GC and AT over the resolved bases, and the per-symbol census with the ambiguity codes broken out. The nucleic-acid counterpart of `protein_properties`, and the same derivation the editor's Properties panel,
• record_experiment ~688 tokens
  Write what just happened into your lab notebook: a new entry, or more text appended to one you name. The body is markdown and its @plasmid / !action / &gel references are extracted as you write, so an entry made by a run is cross-linked exactly like one you typed — and carries the `automated` tag, s
• relative_expression ~2224 tokens
  Relative gene expression from a Ct table, by all THREE models the Analyze panel offers: delta-delta-Ct (normalised to a reference gene AND calibrated to a reference group), delta-Ct (calibrated to a reference group only), and the two-step standard-curve model, which fits each gene's own dilution ser
• research_run_status ~504 tokens
  Read a research run file without running anything: whether its seal holds (an edited or truncated file is refused), every hypothesis's verdict and the rule its evidence was merged by, which hypotheses a resume would run (no evidence, and the last attempt failed or was deferred by a call's budget) an
• restriction_ligate ~894 tokens
  Cut and ligate in ONE POT (pydna restriction_ligation_assembly): every input is digested by the same enzymes inside the reaction and the pieces are joined as they appear, so a junction that re-forms a recognition site can be cut again. This is the reaction Golden Gate is a special case of, and it is
• resume_research_run ~656 tokens
  Continue a research run from its file after an interruption or a failed test: the seal is checked, every pinned input the corpus still holds must have the content it had (a changed file is refused by name), and only the hypotheses with no evidence whose last attempt failed or was deferred are run, e
• reverse_complement ~330 tokens
  Reverse-complement the subject sequence. Emits a NEW record, so downstream nodes (map, digest, gel, ORF) run on the revcomp rather than the original.
• run_discovery_programme ~2241 tokens
  Run a discovery program end to end under pre-registration: every hypothesis names its test (discover_site_avoidance: a site, optionally a record, and its null; discover_codon_outliers: a gene and its genetic code; validate_gene_trait: a human gene, the trait's own gene or tissues, and GWAS Catalog c
• run_gel_lane ~492 tokens
  Resolve a gel lane (ladder / plasmid / digest / pcr) into [bp, form] bands for the open plasmid.
• run_workflow ~1722 tokens
  Run a workflow graph: nodes naming tools, wires carrying one node’s output into another’s input, `$whenExpression` to make a step conditional, and `scatter` to run a step once per element of a list. Returns the run record — per-node status, outputs and errors, in topological order.
• scan_intrinsic_terminators ~810 tokens
  Find rho-independent (intrinsic) transcription terminators in a bacterial sequence: a stem-loop followed by a thymine-rich tail, scored by TransTermHP's published model (Kingsford, Ayanbule & Salzberg 2007). TWO NUMBERS, BOTH LOWER IS STRONGER - how well the hairpin folds and how thymine-rich the ta
• scan_motif_sites ~551 tokens
  Find every place a transcription-factor binding motif (a position-frequency matrix, such as a JASPAR matrix's counts) matches a DNA sequence, on both strands, at a threshold set per motif as a fraction of that matrix's own score range. It is the scan the optimizer's avoid-motif specification counts,
• scan_sigma70_promoters ~850 tokens
  Find σ70 (housekeeping) promoters in a bacterial sequence and say how strong each one is, using the published La Fleur-Hossain-Salis biophysical model - six interaction motifs (UP element, -35, spacer, extended -10, -10, discriminator) plus the R-loop strength of the first transcribed bases, fitted
• scan_splice_sites ~808 tokens
  Find the splice sites a sequence accidentally spells - the check a codon-optimised CDS needs before it goes into a plant or any other eukaryotic host, because a synonymous swap chosen for codon usage or GC can spell a donor or acceptor that was not there before, and the transcript is then spliced so
• score_overhang_fidelity ~840 tokens
  Score a Golden Gate junction (fusion-site) set against MEASURED T4 DNA ligase end-joining data. It is the number NEB's Ligase Fidelity Viewer reports: the expected fraction of assemblies in which EVERY junction ligated correctly. This is the quantitative counterpart to check_golden_gate_parts: that
• score_rbs ~443 tokens
  Score the ribosome-binding site already in front of a start codon: the Shine-Dalgarno hybridisation energy, the mRNA folding that competes with it, the spacing it implies, and the resulting relative initiation strength. This reads an existing 5'UTR — design_rbs writes a new one.
• score_spectrum ~576 tokens
  Score how well an MS/MS spectrum matches a peptide with the X!Tandem HyperScore (validated against OpenMS): b and y ions are generated for the peptide, matched to the observed peaks within a tolerance, and scored as ln(1 + dot product) + ln(matched b!) + ln(matched y!).
• screen_guides ~652 tokens
  Screen guide spacers the way CHOPCHOP does before it accepts them: GC gate, self-complementary hairpins inside the spacer, and hairpins against the sgRNA backbone. A guide that folds onto its own scaffold is loaded into Cas9 poorly however good its on-target score is, so this is the check that expla
• screen_oligo_structure ~879 tokens
  Fold a set of oligos and check them against each other: every oligo's hairpin, its self-dimer anywhere and its self-dimer at the 3' end, plus the cross-dimer with every other oligo in the set, at any position and at a 3' end. This is primer3's `thal` — the same engine the Tm columns elsewhere use —
• scrub_restriction_sites ~566 tokens
  Propose the minimal SILENT synonymous edits that remove forbidden restriction sites from a CDS (a design/write).
• search_off_targets ~865 tokens
  Search a sequence for sites a guide could also cut, allowing mismatches, and score each one (MIT and CFD) plus the aggregate specificity of the guide WITHIN that sequence. This is specificity against what you searched — it is not a genome-wide score, and it says so rather than inventing one.
• select_substitution_model ~751 tokens
  Choose the substitution model for a maximum-likelihood phylogeny by fitting every candidate — model x rate-heterogeneity x invariant-sites — on ONE shared topology and ranking them by AIC, AICc or BIC with Akaike weights. Fitting on a shared topology is the point: a model test that also searched top
• simulate_rnaseq_power ~1474 tokens
  Power and FDR for a two-group RNA-seq experiment by SIMULATION (PROPER 1.44.0): whole experiments drawn from a real pilot (Cheung, Gilad, Bottomly, MAQC, or a sequencing depth), each run through edgeR's exact test at every sample size. Reports power stratified by expression, the FDR actually achieve
• simulate_taqman_curve ~1618 tokens
  Predict the amplification curve a hydrolysis-probe (TaqMan) qPCR assay will draw, and the Cq read off it, from the assay's own sequences and its thermocycling programme - a forward simulation, not a fit to data. Ports DYNAMIC (Kreitmann et al., Anal. Chem. 2026, 98(12):9089-9101): thirteen species,
• solve_dilution ~787 tokens
  Solve C₁V₁ = C₂V₂ for whichever of the four quantities is left empty (stock concentration, stock volume, final concentration, final volume), each in its own unit: molar (M to fM), mass per volume (mg/mL to ng/mL), fold (X) or percent. Returns all four, the fold and the diluent volume to add. Refuses
• summarize_rows ~1350 tokens
  Reduce a whole TABLE column to one number — the largest band, the median guide score, the spread of a set of melting temperatures. This is what makes a CROSS-ROW check expressible: `check_rows` can only assert the same thing of every row, so "the largest fragment is at least twice the smallest" need
• survey_off_targets ~824 tokens
  Count every guide's off-target sites by mismatch class across one sequence, in one pass — the question that comes BEFORE opening any single guide's site table: which of these spacers is worth looking at. Returns counts and the aggregate specificity per spacer, never the sites themselves, so a few hu
• target_decoy_qvalues ~632 tokens
  False discovery rate and q-values for peptide-spectrum matches by target-decoy competition (validated against pyteomics): give each match's score and whether it hit a decoy; returns every match's q-value, the whole set's FDR, and how many targets pass a q-value threshold. Supports the +1 and finite-
• transform_tree ~846 tokens
  Edit a tree that is already built — re-root it (at its midpoint, on an outgroup, or remove the root), prune taxa away or down to a set, ladderize it, or collapse branches that are too weakly supported or too short to believe. Pruning the TREE keeps the branch lengths estimated from the full alignmen
• translate_sequence ~598 tokens
  Translate the subject DNA to protein (Biopython `Bio.Seq.translate` semantics). The SUBJECT is the selection when there is one, the named feature when `feature` is given, and the whole record otherwise — the `region` output says which, so never paste bases in to scope it.
• tree_statistics ~405 tokens
  Describe a tree without rebuilding it: its shape statistics (tips, height, balance, the gamma statistic), the lineages-through-time curve, and the patristic distance matrix — the path lengths through the tree, which is what to compare against the alignment distances that built it.
• tree_taxon_annotations ~424 tokens
  Read what a NeXML tree file says about each of its taxa: every annotation on every OTU (an NCBI taxon, a rank, a parent taxon), one row per annotation, plus how many distinct values each property takes. This is the tip data the phylogeny canvas draws as a strip beside the tips, where a value that re
• trim_reads ~1116 tokens
  Trim sequencing adapters and low-quality ends off FASTQ reads before mapping, and report what was removed. This is cutadapt's algorithm: quality trimming is BWA's running-sum rule (not a threshold - a single bad base in a good tail is absorbed, a real decline is not), and the adapter is found by sem
• validate_gene_trait ~1011 tokens
  Put a hypothesis of the form "gene G is involved in trait T" through POPPER-style sequential falsification on two public tables, each test fixed in advance and run in a fixed order. (1) GTEx v8 expression: either G's co-expression across the 54 tissues with the trait's own gene(s), such as IL2 for I
• validate_workflow ~1696 tokens
  Would this workflow graph run? Returns the blocking errors — an unknown tool, a wire into a port that does not exist, a cycle — each naming the node and the port, without running anything.
• verify_read ~698 tokens
  Grade a sequencing read against a reference (✓ verified / ⚠ near / ~ partial / ✗ divergent) from an alignment.

Browse

• GitHub tools
• Spreadsheets
• Project management
• GitHub and code hosting
• Translation

Related MCP servers

• Seqbench Workbench
  Hosted DNA/RNA/protein tools: primers, oligos, PCR, cloning, CRISPR, alignment, batch & pipelines.
• Corollary — scientific AI models, tools and databases
  Find open biology and chemistry AI models, bioinformatics tools and databases, and run them online.
• Ensembl
  Ensembl REST MCP.

Badge for your README

[![AptLynx](https://aptlynx.net/badge/io.github.genmnz/jean.svg)](https://aptlynx.net/servers/io.github.genmnz/jean)

Listing text is written by the maker; AptLynx lists tools and does not vouch for them. Find another tool · Browse by topic · For agents