MCP server

Seqbench Workbench Official

com.seqbench/workbench

Checked 25 Oct 2026, 20:29 UTC · Connected to it and listed its tools

Hosted DNA/RNA/protein tools: primers, oligos, PCR, cloning, CRISPR, alignment, batch & pipelines.

Website

At a glance

Type

MCP server

Publisher

seqbench.com (verified by the MCP Registry)

Status

Working at last check

Tools

153

Token cost

About 77,980 tokens per request

Sets up in

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

Last checked

25 Oct 2026, 20: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 workbench https://seqbench.com/api/mcp

Claude Desktop

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

Codex (config.toml)

[mcp_servers.workbench]
url = "https://seqbench.com/api/mcp"

Gemini CLI

{"mcpServers":{"workbench":{"httpUrl":"https://seqbench.com/api/mcp"}}}

Cursor

{"mcpServers":{"workbench":{"url":"https://seqbench.com/api/mcp"}}}

VS Code

{"servers":{"workbench":{"type":"http","url":"https://seqbench.com/api/mcp"}}}

Antigravity

agy mcp add workbench https://seqbench.com/api/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":"workbench","server_url":"https://seqbench.com/api/mcp","require_approval":"always"}

Grok (xAI API tools)

{"type":"mcp","server_label":"workbench","server_url":"https://seqbench.com/api/mcp"}

Tools

• alphafold_lookup ~124 tokens
  Look up a UniProt accession in the AlphaFold Protein Structure Database (CC-BY 4.0). Returns confidence, model version and structure file URLs, or {found:false} when no prediction exists for that accession.
• annealing_temperature ~611 tokens
  Annealing temperature and a full cycling program for a primer PAIR, under the rule the polymerase's own vendor publishes — which is not one rule, and is only defined against the vendor's own Tm. For NEB products the Tm is computed exactly as NEB's Tm calculator computes it (SantaLucia 1998 nearest-n
• aso_design ~277 tokens
  Design antisense-oligonucleotide (ASO) gapmers against an mRNA target: scans candidate sites, builds the antisense oligo in the standard 5-10-5 architecture (chemically-modified wings, central DNA gap for RNase H1, phosphorothioate backbone), and screens each for known liabilities (G-quadruplex moti
• assembly_outcomes ~614 tokens
  Enumerate the specific wrong plasmids a multi-part Golden Gate or Gibson assembly can produce — a part dropped, inverted, duplicated, two parts swapped, the backbone self-circularized — as full sequences, ranked by how few independent mis-ligations each needs. Golden Gate outcomes are annotated with
• band_traceback ~534 tokens
  Explain a band you measured on a gel. Given the template, both primers and the observed size, it enumerates every pair of priming sites — including a single primer priming both strands — that would give a product that size, and ranks them by how much of each primer's 3' end matches without interrupt
• barcode_audit ~337 tokens
  Take a set of barcodes and report the minimum edit distance in it, which pairs sit at that distance, any duplicates, the GC range and the longest homopolymer. The pairs are the point: 'minimum distance 2' is a number, and 'these two barcodes are one substitution apart' is something to fix. Use befor
• barcode_design ~796 tokens
  Build a set of DNA barcodes that are pairwise at least a chosen edit distance apart, so a read error cannot turn one barcode in the pool into another. Honours a GC window, a homopolymer cap and excluded motifs (the restriction sites you clone with) during the search rather than filtering afterwards,
• base_edit_quant ~1508 tokens
  Quantify CBE/ABE base editing from a pair of Sanger traces — an unedited control and the edited pool — without NGS. At each editable position in the activity window the edited trace is treated as a mixture of the unedited and converted peaks, and the control's OWN alt-channel signal at that same pos
• base_editing_design ~359 tokens
  Design cytosine (CBE, C→T) or adenine (ABE, A→G) base-editing gRNAs for an SpCas9 target: for each NGG gRNA it reports every editable base inside the editor's activity window, flags bystander edits (more than one editable base in the window), and — with a CDS reading frame — classifies each edit's a
• batch ~157 tokens
  Run one batchable SeqBench tool over many records. Returns a table of per-record results and typed failures.
• blast_poll ~240 tokens
  Check a BLAST search submitted with blast_submit. Returns {ready:false} while it is still running; once ready, returns each hit's accession, title, organism, best HSP (bit score, expect, percent identity, span on both query and subject) and the percentage of the QUERY it covers, with overlapping HSP
• blast_submit ~743 tokens
  Submit a sequence to NCBI BLAST and get a request id back immediately — poll it with blast_poll. The program is inferred from the sequence (nucleotide to blastn, protein to blastp) unless you name one, and a query whose type does not match the named program is refused rather than silently returning
• centrifuge_conversion ~238 tokens
  Convert between rotor speed (RPM) and relative centrifugal force (×g) for a given rotor radius, in either direction. The conversion is exact physics — RCF = ω²r/g — and the only judgement in it is which radius: a protocol's ×g conventionally means the rotor's MAXIMUM radius, and using the wrong one
• characterize_sequence ~233 tokens
  One-paste 'tell me everything': auto-detects DNA/RNA/protein, then reports composition, ORFs, single-cutter enzymes, end primers or protein properties, plus a BLAST link.
• cloning_diagnose ~2055 tokens
  Work out why a cloning experiment failed: no colonies, every clone empty vector, or no PCR band. Takes your design (method, parts, enzymes, primers, host methylation state) plus what you actually observed (colony counts on the plate and on each control, screening tally, band sizes, whether the ladde
• cloning_next_observation ~1974 tokens
  Rank every observation you have not yet made by how many open causes it settles WHICHEVER WAY IT COMES OUT, then return the smallest set of observations that settles all of them. Takes the same arguments as cloning_diagnose. The ranking is computed by re-running the diagnosis at each possible outcom
• cloning_simulate ~2106 tokens
  Assemble fragments by Gibson/overlap, Golden Gate (Type IIS), restriction–ligation (sticky or blunt), TOPO/TA, LIC or SLIC (T4-polymerase chew-back) or In-Fusion/CPEC, returning the product, the junctions and — for the primer-design methods — the junction primers. Each method is modeled as its own c
• codon_adaptation_index ~309 tokens
  Codon Adaptation Index (CAI) and per-codon relative adaptiveness of a CDS against an expression host, with rare-codon and GC3 analysis.
• codon_optimize ~255 tokens
  Codon-optimize a protein (or coding DNA) for an expression host by picking the most-frequent codon per residue.
• construct_autofix ~476 tokens
  Iteratively substitutes synonymous codons to resolve unwanted restriction sites (domestication for Golden Gate), homopolymers, tandem repeats, predicted secondary structure, cryptic RBS/polyA motifs and hidden alternate-frame ORFs that construct_qc flags — without changing the encoded protein (verif
• construct_qc ~382 tokens
  Lint a coding DNA sequence for premature stops, internal RBS/polyA motifs, unwanted restriction sites, GC extremes and repeats.
• cpg_islands ~535 tokens
  Find CpG islands by either published definition: Gardiner-Garden & Frommer 1987 (GC > 50%, observed/expected CpG > 0.6, >= 200 bp — the original, which also calls many Alu repeats) or Takai & Jones 2002 (GC >= 55%, obs/exp >= 0.65, >= 500 bp — written to exclude them). Windows are merged only where
• crispr_grna_design ~462 tokens
  Find and score candidate guide RNAs (protospacer + PAM) in a target DNA for common nucleases (SpCas9, SpCas9-NG, SaCas9, Cas12a). PREDICTED, NOT MEASURED. No held-out skill statistic is claimed. Both are pre-2016 models, superseded by Rule Set 3 (DeWeirdt et al., Nat Commun 2022) and by DeepHF. Rule
• crispr_hdr_donor ~732 tokens
  Build an HDR donor (homology arms flanking an edit) from a target sequence and either an explicit edit window (editStart/editEnd) or a guide's cut site (guideStart/guideEnd/guideStrand/nuclease — SpCas9-family only; Cas12a's staggered cut needs an explicit editStart/editEnd). Also designs genotyping
• crispr_offtarget_check ~643 tokens
  Screen a guide's protospacer for off-target sites (protospacer match + valid PAM, both strands) against a small curated set of common lab reference genomes (see genomesChecked) — NOT a whole human/mouse genome search. For SpCas9 with a 20 nt spacer each site also gets a Doench 2016 CFD score, so sit
• crispr_ontarget ~872 tokens
  Score SpCas9 guides for on-target activity with Rule Set 3 (DeWeirdt et al., Nat Commun 2022) — the current successor to the Doench 2014 and CRISPRscan scores crispr_grna_design reports. Give a target sequence to find and score every NGG guide in it — on both strands unless `searchReverseStrand` say
• cross_dimer ~114 tokens
  Screen two oligos for the most stable heterodimer (cross-dimer) between them.
• diagnostic_digest ~633 tokens
  Pick the restriction digest that tells your intended construct apart from the wrong ones on a screening gel. Digests every candidate, works out which bands would actually resolve at the chosen agarose percentage (size ratio, the gel's resolving window, and whether a band is too faint to score), and
• dna_molarity ~428 tokens
  Nucleic-acid quantity conversions: molar mass, amount (pmol/nmol), molar and mass concentration, and copy number, from mass ± volume and either a length or a sequence.
• dot_plot ~416 tokens
  Word-match dot plot between two sequences, on both strands, returned as diagonal RUNS rather than points. This is the view that shows what a single best alignment hides: internal repeats, tandem duplications, and inversions — an inversion appears as a run on the falling diagonal and as nothing at al
• double_digest ~114 tokens
  Recommend a single NEB buffer (and flag caveats) for digesting with two enzymes in one tube.
• editing_plate_quantify ~2314 tokens
  Quantify a whole plate of edited samples against ONE untreated control trace and return a single sortable table — the plate-scale form of sanger_indel_spectrum, base_edit_quant and sanger_knockin_quant, chosen with `mode`. Each sample gives one row keyed by its id, carrying the headline number for t
• elsa_capacity ~196 tokens
  Report how many promoters, sgRNA handles and neutral spacers are available at each maximum-shared-length threshold, and therefore the longest extra-long sgRNA array that can be built without reusing a part. Ask this before designing: the answer is a property of the measured parts collection, not of
• elsa_design ~519 tokens
  Build a multiplexed CRISPR array that expresses many sgRNAs from one cassette and shares no long stretch with itself. Twenty sgRNAs built the obvious way carry twenty copies of the same Cas9 scaffold, promoter and terminator — a construct that recombines in the cell and that synthesis vendors refuse
• export_echo_picklist ~470 tokens
  Generate a downloadable Beckman/Labcyte Echo acoustic-liquid-handler picklist CSV (columns: Source Plate Name, Source Plate Type, Source Well, Destination Plate Name, Destination Well, Transfer Volume, Name — the header row reproduced from PyEcho, a real open-source Echo-picklist generator) for the
• export_opentrons_protocol ~465 tokens
  Generate a downloadable Opentrons Python Protocol API (v2, OT-2) script that sets up the given PCR reactions on a 96-well PCR plate, at the same well positions export_plate_layout assigns. Uses real Opentrons labware/pipette API names confirmed against docs.opentrons.com and the Opentrons shared-dat
• export_plate_layout ~312 tokens
  Assign a set of PCR reactions (name + forward/reverse primer + optional template label) to wells on a 96-well plate, row-major (A1, A2, … A12, then B1, B2, … up to H12). Returns the well-assignment data for rendering a plate diagram; export_opentrons_protocol and export_echo_picklist build their dow
• expression_cassette_check ~395 tokens
  Check the ARRANGEMENT around each coding sequence, which is what decides whether a finished clone expresses at all: a promoter for the named host within reach on the same strand, a Shine-Dalgarno at a workable spacing (bacteria) or a Kozak context (eukaryote), every tag in the CDS's own reading fram
• expression_heatmap_cluster ~494 tokens
  Hierarchically cluster a genes x samples expression matrix (UPGMA/average, complete, or single linkage; Euclidean or correlation distance) and return the row/column leaf order, dendrogram merge trees, and row-z-scored values for the Clustered Expression Heatmap visualization.
• fasta_filter ~368 tokens
  Keep a subset of a FASTA file: by length, by a LIST of names (the shape "filter by ID" actually takes — two hundred accessions, not one substring), by a drop list, and by removing records that are the same sequence twice. Every dropped record comes back named with the one rule that removed it, becau
• fastq_qc_report ~206 tokens
  FastQC-style deep quality-control report for a FASTQ file: per-base quality and content, GC and length distributions, sequence duplication levels, overrepresented sequences, and adapter content — each with a warn/fail verdict against FastQC's own published thresholds.
• fastq_trim ~290 tokens
  Trim FASTQ reads: an ungapped sliding-suffix adapter match (against the same named Illumina adapters as the QC report) followed by a BWA-style 3' quality trim (the same algorithm Cutadapt's own -q option reuses), then drops reads below a minimum length. Returns the trimmed FASTQ plus before/after re
• find_orfs ~209 tokens
  Find open reading frames (ATG…stop) across all six frames.
• format_sequence ~240 tokens
  Clean, case-fold, DNA↔RNA convert, reverse and line-wrap a sequence.
• functional_enrichment ~433 tokens
  Over-representation analysis: test which GO terms (biological process / molecular function / cellular component) and Reactome pathways are statistically enriched in a query gene list versus a background, using the hypergeometric test with Benjamini-Hochberg FDR correction across all tested terms. Us
• gc_content ~90 tokens
  GC content, AT content and per-base composition of a sequence.
• gel_band_size ~515 tokens
  Calibrate a gel lane against a marked DNA ladder and read the size of any other band from how far it ran. Migration distance is approximately linear in log(size) over a gel's resolving range, so a least-squares line through the marked rungs interpolates between them — and NOT outside them, which is
• gene_dossier ~235 tokens
  A gene/drug-target dossier fanned out to five independent sources in one call: Open Targets (function, tractability, top associated diseases), an NCBI/UniProt plain-English function summary, ChEMBL (known drugs and their mechanism/clinical phase, cross-referenced with indications), ClinicalTrials.go
• gene_expression ~127 tokens
  A gene's tissue-expression fingerprint: per-tissue median TPM from GTEx (v8) and subcellular localization / RNA tissue-specificity / protein class from the Human Protein Atlas, in one call.
• gene_model ~124 tokens
  The real exon/UTR/CDS structure of a human gene's canonical transcript, fetched live from Ensembl (the same exon/CDS map the HGVS Converter tool uses) — for rendering an exon diagram.
• genome_region ~464 tokens
  Find a gene in an assembly by symbol or locus tag and return its sequence with however much flanking DNA you ask for — the step before designing a knockout, a C-terminal tag or an HDR donor, where you know the gene's name but not its coordinates. Give the assembly accession (GCF_000005845.2 for E. c
• golden_gate_design ~658 tokens
  CHOOSE a set of 4-base Golden Gate/MoClo junction overhangs, rather than scoring one you already have. Maximizes the fidelity of the set's WEAKEST junction against the same published T4-ligase ligation data golden_gate_fidelity scores with, subject to every member actually ligating well — an overhan
• golden_gate_fidelity ~428 tokens
  Score a candidate set of 4-base Golden Gate/MoClo junction overhangs against real published T4-ligase ligation-count data: per-overhang specificity, the weakest link in the set, and any risky cross-reacting pairs. Optionally compare against a named published overhang set. This is SeqBench's own tran
• golden_gate_from_parts ~413 tokens
  Golden Gate as the reaction runs: digest pre-domesticated part plasmids with a Type IIS enzyme and assemble them in the order their OVERHANGS dictate. The fragment released from each part is the one carrying no recognition site (the site goes out with the backbone, which is why a mis-ordered assembl
• golden_gate_library ~404 tokens
  Every combination of interchangeable part plasmids, assembled. Give the alternatives at each position — three promoters, four coding sequences, two terminators, one backbone — and it builds all twenty-four, reporting which close into a plasmid, which do not and why, and whether two combinations buil
• hgvs_convert ~559 tokens
  Parse an HGVS "c." variant description (by gene symbol, RefSeq NM_, or Ensembl ENST accession), convert it to genomic (g.) coordinates via a real, live-fetched Ensembl exon/CDS map (transcripts resolved through the bundled MANE RefSeq<->Ensembl crosswalk), apply 3'-rule normalization to any del/dup/
• id_map_poll ~118 tokens
  Check a UniProt id-mapping job submitted via id_map_submit. Returns {status, ready:false} while still running; once FINISHED, also returns the mapped ids (normalized regardless of which target database was requested) and any ids that failed to map.
• id_map_submit ~372 tokens
  Submit up to 100,000 ids to UniProt's ID mapping service for a single confirmed-safe hop (e.g. Gene_Name -> UniProtKB-Swiss-Prot, or UniProtKB_AC-ID -> Ensembl/GeneID/RefSeq_Protein/Gene_Name). Returns a jobId immediately — poll it with id_map_poll.
• identity_matrix ~288 tokens
  Percent identity between every pair in a multiple alignment. Takes ALIGNED sequences — the output of multiple_sequence_alignment — because inferring an alignment here would bury the aligner's parameters inside a number that reads as a property of the sequences. Two percentages come back per pair: ov
• in_silico_pcr ~664 tokens
  Predict PCR products for a template and a pair of primers (IUPAC-aware, allows mismatches, handles circular templates). Primers may carry a non-templated 5' tail — a restriction site, a Gibson arm, a Kozak, a tag: a primer primes on its 3' end, and the tail is carried into the product rather than re
• kasp_primer_design ~583 tokens
  Design KASP/ARMS allele-specific genotyping primers for a SNP: two allele-specific forward primers differing only at the 3' terminal base (one per allele), each with the standard KASP universal tail (FAM for allele A, HEX for allele B), a deliberate internal ARMS secondary mismatch near the 3' end w
• ligation_setup ~627 tokens
  Work out how many microlitres of vector and insert to pipette to hit a target molar ratio, from each part's length and stock concentration. Handles one insert or several with independent equivalents (Gibson, Golden Gate, MoClo), reports pmol and ng per part alongside the volumes, and flags the two t
• map_update_from_consensus ~488 tokens
  Write the differences a whole-plasmid sequencing consensus shows into the map, keeping the map's annotation: every feature is shifted, grown or shrunk with the edit, a feature whose boundary an edit cuts is trimmed (and named), and differences in a known nanopore error context (Dam/Dcm methylation s
• melting_temperature ~326 tokens
  Primer/oligo melting temperature: nearest-neighbor (SantaLucia 1998) at the supplied reaction conditions, recommended from 14 nt up, with the Wallace rule for shorter oligos, a fixed-100 mM-Na+ Schildkraut-Lifson reference estimate, and molecular weights.
• motif_discover ~668 tokens
  Find a motif NOBODY TYPED: given a set of sequences (multi-record FASTA), report the short pattern they share, as a consensus, a position-weight matrix and one site per sequence. This is the opposite question from motif_finder, which searches for a pattern you already have. Gibbs site sampler (Lawre
• motif_finder ~252 tokens
  Find (overlapping) occurrences of an IUPAC motif on either strand, allowing mismatches.
• multiple_sequence_alignment ~144 tokens
  Center-star multiple sequence alignment of a multi-FASTA input — nucleotide or protein, detected from the records and reported as `type` — with consensus and per-column conservation.
• multiplex_panel_design ~776 tokens
  Choose one primer pair per target so the whole panel works in one tube: no cross-dimer between any two of the primers, every amplicon resolvable from every other on the gel you will run, and one annealing temperature that serves all of them. Searches combinations rather than picking each target's be
• nonrepetitive_parts_design ~639 tokens
  Build a set of new genetic parts that match a degenerate (IUPAC) template and share more than a chosen length with nothing — not each other, not themselves, not a background sequence you supply. This is how a toolbox of promoters, RBSs, terminators or sgRNA handles is made large without making an as
• nonrepetitive_parts_find ~476 tokens
  Given a toolbox of genetic parts, return the largest subset in which no two parts share more than a chosen length of sequence — on either strand. Parts that share a long stretch recombine into each other in a multi-part assembly and are the single largest cause of DNA synthesis failure, and neither
• od600_cells ~480 tokens
  Convert an OD600 reading to a cell density and a total cell count, correcting for the optical path and any dilution, and flagging the two things that silently make the number wrong: a reading above the linear range (a dense culture reads LOW), and a plate-reader path length assumed to be a cuvette's
• oligo_analysis ~211 tokens
  Full oligo analysis: nearest-neighbor Tm/ΔG/ΔH/ΔS plus hairpin and self-dimer screening with base-pair diagrams and warnings.
• oligo_cofold ~642 tokens
  Minimum-free-energy structure and ΔG for one oligo (hairpin) or two oligos together (homo/heterodimer), using ViennaRNA's published loop model at a temperature you choose — DNA parameters (Mathews 2004) by default, RNA (Turner 2004) on request. Reports each strand alone, the duplex, and the interact
• oligo_pool_screen ~688 tokens
  Screen a whole set of oligos you already have — every pair for cross-dimers, every oligo for its own hairpin and self-dimer, and the set for duplicates and Tm spread — and get back the conflicts ranked rather than a table of every combination. This is the pool-level answer cross_dimer gives one pair
• operon_design ~595 tokens
  Build a polycistronic operon from a promoter, a list of CDSs with their RBSs, spacers and a terminator — optionally recoding every CDS for a host — then scan the ASSEMBLED molecule for internal promoters, Shine-Dalgarno sequences, terminators, out-of-frame start codons and repeats. Scanning the prod
• operon_scan ~412 tokens
  Scan a multi-gene construct, on both strands, for the sequence that quietly breaks operons: promoter-like -35/-10 pairs (including ones pointing backwards, which make antisense RNA), Shine-Dalgarno sequences positioned in front of an internal start codon, terminator-shaped hairpins with a U-tract, o
• ortholog_map ~326 tokens
  Look up the orthologous (or paralogous) gene for up to 50 gene symbols in a target species, via Ensembl's homology-by-symbol REST endpoint. Symbols with no homology record are reported in `unmapped`, never silently dropped.
• outcome_deconvolve ~657 tokens
  Decompose one Sanger trace into fractions over a set of candidate molecules — the intended construct, the empty backbone, a double insert, a flipped part — instead of onto a generic indel ladder. Non-negative least squares against the candidates' own sequences, so no molecule is ever assigned a nega
• pairwise_alignment ~429 tokens
  Global (Needleman-Wunsch), local (Smith-Waterman) or semi-global/fitting pairwise alignment of two sequences, with match/mismatch scoring and affine gap costs (Gotoh).
• parse_genbank ~126 tokens
  Parse a GenBank flat file into its locus, definition, features and sequence. An EMBL / ENA flat file is accepted too — the same INSDC record in a different layout — and reported with sourceFormat "embl".
• parse_gff3 ~380 tokens
  Read a GFF3 annotation file: every feature with its 1-based inclusive coordinates, strand, phase, score and decoded attributes, plus any sequences from an embedded ##FASTA section. GFF3 usually carries NO sequence — it annotates a separate FASTA, joined on the first column — so the result says which
• parse_sanger_trace ~275 tokens
  Decode a Sanger ABIF (.ab1 / .abi) chromatogram: base calls, per-base quality, the four dye-channel traces, peak locations, and the run's own labels (sample name, well, plate, instrument, run start).
• parse_snapgene ~305 tokens
  Read a SnapGene .dna file: sequence, topology, every feature with its span, strand, display color and qualifiers (spliced and origin-spanning features kept as such), and the saved primer list.
• parse_structure ~323 tokens
  Read a PDB or mmCIF structure file — an RCSB PDB entry, or a model from AlphaFold DB, AlphaFold Server or ColabFold — and report what is in it: every polymer chain with its molecule type, name and one-letter sequence (all chains also as FASTA), how many residues have coordinates and which stretches
• parts_library_search ~430 tokens
  Search a parts list harvested from the annotated features of the vector library — promoters, terminators, RBSs, polyA signals, origins, selection markers, affinity tags, reporters, linkers/MCSs — by name, kind or length. Nothing here is transcribed: every part is the exact sequence a GenBank record
• phylogenetic_tree ~429 tokens
  A neighbour-joining tree from a multiple ALIGNMENT, as Newick. Distances are corrected pairwise identities over the columns where both rows have a residue — Jukes-Cantor for nucleotides, Poisson for protein, the same corrections MEGA applies by default — and the tree is rooted at the midpoint of its
• plasmid_annotate ~160 tokens
  Auto-detect common cloning features (promoters, tags, origins, resistance markers, MCS, primers) on both strands. Signatures under 20 bp must match exactly; longer ones tolerate up to ~10% mismatches so point mutants still annotate — each feature reports its own `mismatches` count and an `exact` fla
• plasmid_deep_annotate ~388 tokens
  Annotate a plasmid against pLannotate's open-source feature library — a much larger signature set (GenoLIB parts + Swiss-Prot + FPbase + Rfam, cross-referenced against ~195k Addgene-deposited plasmids) than plasmid_annotate's built-in curated list, and it reports partial and low-identity hits as gra
• plasmid_dossier ~505 tokens
  Answer the question someone holding an unlabelled tube actually has, rather than returning another feature list: which antibiotic to select on, which host will carry it and at roughly what copy number, which curated backbone it resembles, and what on it will bite you later (duplicate markers, two or
• plasmid_full_report ~272 tokens
  One combined view of 'what is this plasmid': recognized common features (from plasmid_annotate), backbone identity / possible chimera (from plasmid_identify), and — the two crossed together — any region that neither a curated backbone nor a recognized common feature explains. That last list is a tri
• plasmid_identify ~279 tokens
  Screen a query plasmid against a small curated set of common backbones (cloning vectors, expression vectors, BACs — see referencesChecked for the exact list) to identify which one(s) it resembles, separate an unmatched region (normal — your own insert) from a POSSIBLE CHIMERA (a region matching a di
• prime_editing_design ~670 tokens
  Design SpCas9 prime-editing pegRNAs for a substitution, insertion, deletion, or small replacement: for each usable NGG PAM it builds the spacer, a primer-binding-site (PBS) length sweep targeting a ~30 C melting temperature, the reverse-transcriptase template (RTT) that encodes the edit, and the ful
• prime_editing_efficiency ~691 tokens
  Predict per-pegRNA prime-editing efficiency for one edit with PRIDICT2.0, and return the top-scoring pegRNA designs ranked by it. Takes the target as context, the edit in brackets, then context — ACGT...(A/G)...ACGT, with roughly 100+ bp each side — and enumerates PBS/RTT length combinations, scorin
• prime_editing_twin_design ~523 tokens
  Design a twinPE pegRNA pair (Anzalone et al. 2022) for a replacement too large for a single pegRNA's RTT: a left pegRNA nicks the + strand at/before the replacement window and a right pegRNA nicks the - strand at/after it, each synthesizing a new 3' flap; both flaps are truncated at a shared overlap
• primer_design ~711 tokens
  De-novo PCR primer design (Primer3-style penalty picker): enumerate and score candidate primer pairs against length/Tm/GC/3'-clamp/structure constraints.
• primer_site_accessibility ~452 tokens
  Fold the template around each place a primer binds, at the annealing temperature and under DNA parameters, and report how much of the primer's own footprint sits inside a helix. Primer design tools score the oligo — its Tm, its hairpin, its dimers — and leave the template unexamined, while a binding
• primer_specificity ~1418 tokens
  Self-hosted e-PCR-style screen for off-target amplicons predicted by a primer pair against the background chosen with `background`: the bundled lab genomes (the default — E. coli K-12 MG1655, B. subtilis 168, human mitochondrion rCRS, Mycoplasma hyorhinis SK76), or the human or mouse TRANSCRIPTOME,
• promoter_library_design ~1040 tokens
  Build a set of sigma-70 promoters that (a) share no more than a chosen length of sequence with each other, so the library does not recombine with itself once integrated, and (b) span a range of predicted transcription rates, picked as an evenly log-spaced ladder. Variants are constructed determinist
• promoter_predict ~560 tokens
  Scan DNA for E. coli sigma-70 promoters and estimate each one's transcription initiation rate, with the free-energy terms it is built from: the -35 and -10 boxes, the spacer, the discriminator, the extended -10 and the initial transcribed region. Pairs with rbs_predict — together they separate 'noth
• protease_digestion ~320 tokens
  In-silico protease/chemical digestion: cleave a protein and report each peptide's position, length and neutral mass. CNBr masses assume terminal Met becomes homoserine lactone; the sequence retains M and the response labels the modification.
• protein_annotate_poll ~305 tokens
  Check an InterProScan job submitted via protein_annotate_submit. Returns {status, ready:false} while still running; once FINISHED, also returns the parsed domain architecture, per-match details, deduplicated GO terms, and `topology` — the MEMBRANE TOPOLOGY and SIGNAL PEPTIDE that EBI's default run i
• protein_annotate_submit ~277 tokens
  Submit a protein sequence to EBI InterProScan for domain architecture, family and GO-term annotation, AND for membrane topology and signal-peptide prediction — EBI's default run includes Phobius, TMHMM and SignalP, so a transmembrane helix, its inside/outside topology and a cleaved signal peptide al
• protein_hydrophobicity ~419 tokens
  Sliding-window hydropathy/hydrophobicity profile (ProtScale-style) over a published amino-acid scale. On the Kyte-Doolittle scale it also returns `hydrophobicStretches`: spans where the 19-residue average stays at or above 1.6, the line Kyte & Doolittle (1982) draw for a membrane-buried segment. ⚠️
• protein_properties ~299 tokens
  Protein properties: molecular weight, isoelectric point, GRAVY, extinction coefficient and composition.
• qpcr_assay_design ~636 tokens
  Design a qPCR assay: primer pairs under qPCR's own constraints (70-150 bp product, tightly matched Tm) each with the best hydrolysis (TaqMan-style) probe that fits between them. The probe sits 6-12 °C above the warmer primer, never begins with G — a 5' guanine quenches the reporter even after the pr
• qpcr_ddct ~448 tokens
  Relative quantification from Ct values: ΔCt, ΔΔCt and fold change, with the standard error propagated from replicates. Picks the method from the amplicon efficiencies rather than leaving it to you — Livak's 2^-ΔΔCt when both are 100% efficient, the Pfaffl efficiency-corrected ratio when they are not
• random_sequence ~142 tokens
  Generate a random DNA, RNA or protein sequence, optionally with a target GC content.
• rbs_design ~854 tokens
  Design a 5' UTR / ribosome binding site for a given CDS. Generates a spread of Shine-Dalgarno cores and SD-to-start spacings, scores every one with OSTIR in the context of your own CDS (which matters — the rate depends on how the RBS interacts with that CDS's 5' folding), and returns them ranked. Su
• rbs_library_design ~948 tokens
  Build a ladder of ribosome binding sites whose predicted translation initiation rates are evenly spread, in log space, across a range you choose — the standard way to titrate one enzyme's level in a pathway without guessing. Scores every SD-core/spacing/spacer-composition combination with OSTIR in y
• rbs_occlusion ~477 tokens
  Find every stretch of a transcript that is reverse-complementary to the ribosome's footprint (-20 to +13 around the start codon), with the length and nearest-neighbour Tm of each duplex, and flag the ones that cover the Shine-Dalgarno core or the start codon. This is the mechanism every translationa
• rbs_predict ~705 tokens
  Predict the translation initiation rate at each start codon in a bacterial mRNA using OSTIR, the open-source continuation of the Salis lab RBS Calculator, with ViennaRNA free energies. Returns the predicted rate plus the full thermodynamic breakdown (16S rRNA:mRNA hybridization, mRNA unfolding, spac
• read_placement_plan ~466 tokens
  Given the molecules a cloning reaction could have produced and the sequencing primers you could use, work out which primers separate which pairs of candidates — and return the smallest set that separates every pair any of them can. Scores a read by discrimination, not coverage: a read of 700 bases e
• repeat_instability ~472 tokens
  Find the exact direct repeats in a construct that make it deletable, and build the molecule each pair would collapse to. Two copies of the same terminator or promoter in a multi-gene assembly let the DNA between them recombine out — silently, so the clone grows and the map looks right until it is se
• restriction_sites ~282 tokens
  Find restriction enzyme recognition sites in a DNA sequence.
• reverse_complement ~112 tokens
  Reverse, complement and reverse complement of a DNA or RNA sequence.
• reverse_translate ~179 tokens
  Back-translate a protein to DNA (most-frequent codon per organism, or degenerate IUPAC consensus).
• riboswitch_states ~736 tokens
  Fold a transcript twice — once freely, once with the aptamer held out of the secondary structure as a bound ligand would hold it — and report what changes at the ribosome binding site. Returns both structures, both free energies, the cost of occupying the aptamer, and whether the site becomes more o
• rna_fold ~336 tokens
  Predict an RNA secondary structure by minimum free energy (MFE) with ViennaRNA's full Turner 2004 loop model at 37 °C (no pseudoknots). Returns the dot-bracket structure, the MFE (kcal/mol), the list of base pairs, and the engine that produced them. PREDICTED, NOT MEASURED. Benchmarks of MFE folding
• sanger_assemble ~426 tokens
  Assemble two or more Sanger reads into a contig WITHOUT a reference sequence — the forward/reverse pair of one insert, or a set of tiling reads. Orientation is worked out from the overlaps, ends are quality-trimmed, and the consensus is quality-weighted. Reports depth and agreement per position, eve
• sanger_indel_spectrum ~971 tokens
  Quantify CRISPR editing from a pair of Sanger traces — an unedited control and the edited pool — by decomposing the edited trace onto shifted copies of the control. Returns the indel spectrum (how much of the pool carries each insertion or deletion size), the unedited fraction, and the R² of the dec
• sanger_knockin_quant ~1680 tokens
  Measure the rate of a SPECIFIC intended edit from a pair of Sanger traces — an unedited control and the edited pool — by decomposing the edited trace onto three things at once: the wild-type allele, the intended edited allele, and the unintended indels. Serves both readouts that need this: HDR knock
• sanger_plate_verify ~1029 tokens
  Judge a whole plate of Sanger reads against one construct and return one row per clone: PASS, POINT_MUTATION, INDEL, VECTOR_ONLY (the insert is absent), WRONG_INSERT (the backbone matches and the insert does not), LOW_COVERAGE, or AMBIGUOUS. Reads are grouped into clones from their FASTA/FASTQ recor
• sanger_vs_reference ~299 tokens
  Align a Sanger ABIF read to a reference and report identity plus every mismatch, insertion and deletion.
• save_permalink ~184 tokens
  Run a registered tool and save its (arguments, result) pair under a short permanent code that anyone with the link can view read-only (/permalink/{code}). Use this to cite or share a specific result (e.g. a verify_construct or verify_assembly check) rather than re-pasting it.
• seqfile_stats ~151 tokens
  Statistics for a FASTA or FASTQ file: count, length distribution, N50, GC content and (FASTQ) mean quality.
• sequence_fetch ~536 tokens
  Fetch a public DNA/protein record by accession from NCBI Nucleotide, NCBI Protein, UniProt, or Ensembl (e.g. NM_000546, NP_000537, P04637, ENSG00000141510) — the whole record, or with `start`/`end` just that region of it, which is how you take a few kb out of a chromosome instead of downloading the
• sequence_format_convert ~281 tokens
  Convert between FASTA and GenBank (whole sequence, CDS or protein), or export to TSV.
• sequence_report ~211 tokens
  One-click DNA analysis: composition, ORFs, restriction-enzyme scan (single cutters) and end-primer Tm composed into a single report with a copyable text block.
• sequence_search ~265 tokens
  Resolve a gene/organism name — or a raw NCBI search term — to candidate accessions, instead of guessing one. Returns up to maxResults hits (accession, title, organism); pass the accession you want to sequence_fetch.
• sequencing_readback_verify ~1565 tokens
  Align raw Sanger or NGS reads (FASTA or FASTQ) back onto a claimed reference sequence using minimap2, and report per-read mapping identity plus exact variant positions (substitutions/insertions/deletions), with a consensus view across reads and a corrected consensus sequence (the reference with ever
• session_create ~169 tokens
  Start a scratch session that holds several named sequences/values (e.g. vector, insert, forward/reverse primer) for use across multiple tool calls via session_run, instead of re-pasting them into every call. Sessions expire after 24 hours.
• session_get ~141 tokens
  Fetch named entries from a session. Prefer session_run for actually USING the values — it keeps raw sequences out of your context. Use this mainly to inspect or debug what a session currently holds.
• session_run ~343 tokens
  Run any SeqBench tool, resolving selected arguments from a session's named entries instead of pasting them inline, and optionally store selected result fields back into the session by name. This is the main way to chain a multi-part design (vector + insert + primers) across calls without shuttling r
• session_set ~109 tokens
  Add or overwrite named entries in an existing session.
• sirna_design ~484 tokens
  Design siRNA duplexes against an mRNA target using the established Reynolds (2004) 8-criteria score and the Ui-Tei (2004) rules, plus the siDirect seed-duplex Tm off-target flag (≥21.5 °C, computed on siDirect's own RNA/RNA scale: Freier 1986 nearest-neighbor parameters, helix initiation A = −10.8,
• site_directed_mutagenesis ~1102 tokens
  Design site-directed mutagenesis primers (QuikChange overlapping or Q5 back-to-back) for a base substitution, an amino-acid codon swap, or an insertion/deletion/delins. The edit can be given as fields or, more simply, by NAME in `mutation`: "E52K", "p.Glu52Lys", "c.155A>G", "c.76_78del", "c.76_77ins
• solution_prep ~340 tokens
  How much to weigh out for a target molarity and volume: mass = C × V × MW. The molar mass comes from a named reagent's molecular FORMULA (computed, not transcribed) or from a value you supply. A bare name matching two hydration states is refused with both named rather than resolved to a guess — EDTA
• synthesis_complexity ~430 tokens
  Measure the sequence features gene-synthesis vendors screen on — repeats (the single largest cause of synthesis failure), GC extremes, GC swings between adjacent windows, homopolymer runs and hairpin-forming inverted repeats — and report each against the threshold vendors publish. Returns measuremen
• trace_diagnose ~385 tokens
  Diagnose a failing Sanger chromatogram: the longest usable window (Mott trimming), whether there is signal above the noise at all, whether more than one molecule is in the tube and from which base, whether quality collapsed at a homopolymer or tandem repeat the polymerase stuttered through, and whet
• trace_secondary_peaks ~688 tokens
  Read a chromatogram for what the basecaller did not report: positions where a second dye is present under the called base (a heterozygote, or a contaminating template), and bases still visible in the scan past where base calling stopped. Both are arithmetic on the channel intensities already in the
• translate ~139 tokens
  Translate a nucleotide sequence to protein (single frame or all six frames; standard code).
• variant_annotate ~392 tokens
  One-box variant lookup against MyVariant.info: accepts an rsID, chrom:pos:ref:alt (colon- or hyphen-separated), genomic HGVS ("chr17:g.7676154G>C"), or transcript HGVS c. ("NM_000546.6:c.215C>G" / "TP53:c.215C>G", bridged via the hgvs_convert tool). Returns a ClinVar significance summary, gnomAD exo
• variant_comparator ~210 tokens
  Align a query to a reference and call variants (substitutions, insertions, deletions) in HGVS g. notation, with optional coding effects.
• variant_to_construct ~1325 tokens
  Turn one variant into one buildable plan: verify the reference allele actually sits where the coordinate says, apply the edit, design site-directed mutagenesis primers to install it, design KASP/ARMS allele-specific primers to genotype it afterwards, and consolidate everything into a single oligo or
• vector_library_get ~248 tokens
  Return one vector from the library: its GenBank accession and version, length, topology, organism/definition, complete sequence, and the full annotated feature table (type, label, 1-based inclusive start/end, strand, spliced length, and the location descriptor as the record wrote it). Accepts the li
• vector_library_search ~411 tokens
  Browse a curated library of publicly deposited, feature-annotated cloning and expression vectors — by name, category (E. coli cloning/expression, yeast, mammalian, plant binary, BAC/fosmid, recombineering, phage/M13), length window, or annotated feature (e.g. 'T7 promoter', 'ori', 'AmpR'). Each hit
• verify_assembly ~1997 tokens
  Deterministic self-check: given the same method/parts cloning_simulate would use (restriction-ligation, Gibson, Golden Gate, LIC, SLIC or In-Fusion/CPEC — optionally deriving a part by in-silico PCR first), re-derive the expected WHOLE product and diff it against a claimed final sequence. Returns pa
• verify_construct ~651 tokens
  Re-derive a construct's insert from the PCR (template + primers) claimed to have produced it, then check — independently of that claim — whether the expected insert actually appears (either orientation) in the claimed final construct, at what identity, and with exact mismatch positions if not. Optio
• virtual_gel ~264 tokens
  Predict restriction-digest fragment sizes and their gel migration positions against a chosen DNA ladder.
• volcano_plot_data ~261 tokens
  Validate a differential-expression table (gene, log2 fold-change, p-value/FDR) and compute -log10(p) plus up/down/non-significant counts at conventional default thresholds (|log2FC|>=1, p<=0.05), for the Volcano Plot visualization. Invalid rows (non-finite log2FC, or p-value outside (0,1]) are dropp
• web_search ~181 tokens
  Search the live web (via Tavily) for information not covered by SeqBench's own tools — recent literature, protocols, vendor/reagent info, general facts. Returns a short synthesized answer (if available) plus ranked source snippets with URLs. This does not run any bioinformatics calculation itself; u
• whole_plasmid_verify ~512 tokens
  Compare a whole-plasmid sequencing CONSENSUS (the single circular FASTA a nanopore plasmid service returns) against the design it was supposed to be, and say whether they are the same molecule. Finds the rotation and strand itself — an assembler starts the circle wherever it landed and half the time
• workflow ~184 tokens
  Run an ordered multi-tool pipeline over many records. One sequence value can be chained between steps.

Browse

• Tandem tools
• Website monitoring
• Hiring and jobs
• Databases

Related MCP servers

• Jean — Molecular Biology & Genomics
  Validated molecular biology tools: cloning, primers, CRISPR, Sanger, alignment, qPCR, phylogenetics

Badge for your README

[![AptLynx](https://aptlynx.net/badge/com.seqbench/workbench.svg)](https://aptlynx.net/servers/com.seqbench/workbench)

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