dsh-synomega

English | 中文

Topics: dsh-plugin · deepseek-harness · retrosynthesis · cheminformatics · reaction-prediction

Organic reaction prediction for DeepSeek Harness,
backed by SynOmega. Five model-facing tools —
retrosynthesis, forward prediction, route planning, synthesizability scoring, and
multi-component evolution — with molecules, reactions, and route trees drawn in the
conversation, and a molecule editor in the composer so a structure can go out as a
drawing instead of a hand-typed SMILES string.

Everything runs locally. There is no API key and no remote inference: the models are
downloaded once and evaluated on your machine.

"How do I make this molecule?" — the model plans a route and scores it. Two steps, both starting materials purchasable, per-step scores on the edges, SynScore 1.000.

Install

dsh plugin --profile web add github:zbc0315/dsh-synomega

web is the profile to install into — a profile is one named composition of
plugins under $DSH_HOME/profiles/, and dsh web boots the one literally named
web. Use whichever profile you actually start; naming one that does not exist
creates it.

The built entry points are committed, so a git install needs no build step and no
allowBuilds approval. (Once this is on npm, dsh plugin --profile web add dsh-synomega will work the same way.)

Start the harness once afterwards. On first activation the plugin provisions its own
Python environment in the background — a Python 3.12 virtualenv under
$DSH_HOME/plugins/synomega, pip install synomega[gnn], then the retrosynthesis
model, the building-block stock, and the forward model (about 450 MB in total, once).
Nothing blocks the harness from booting; a tool called while setup is still running
reports the phase and asks the model to retry rather than failing.

Provisioning takes a cross-process lock, so a harness starting while you are running
the setup script by hand waits for it instead of downloading the same files twice.

Python 3.10 or newer is required, and a machine's system python3 is frequently
older. Install uv and the plugin will fetch a suitable
interpreter itself; otherwise point the python config at an existing 3.10+ one.

To provision ahead of time instead of on first activation:

node node_modules/dsh-synomega/scripts/setup.mjs            # with the neural backend
node node_modules/dsh-synomega/scripts/setup.mjs --no-extras --no-assets   # template backend only

Tools

Each returns a structured canonical value (usable directly from Code Mode) plus a
compact text rendering for the model. A prompt section teaches the model which tool
answers which question, that every molecule argument must be a SMILES string, and that
the first call after installation is slow because it downloads models.

SynScore is 1/(U+1)^U, where U is the number of starting materials in the best
route that cannot be bought: 1.0 when solved, 0.5 with one missing, 0.11 with two, 0
when no route is found. Use score to rank candidates and the separate solved
boolean to compare against published solve rates — they answer different questions.

Drawing a molecule

Next to the composer's leading controls there is a benzene button. It opens
Ketcher — the structure editor — over the
conversation; Insert appends what you drew to the message as SMILES, leaving the
rest of what you had typed alone.

This exists because the alternative is transcription. A SMILES string typed by hand
is easy to get subtly wrong, and a wrong one still parses: CC(=O)Nc1ccccc1O and
CC(=O)Nc1ccc(O)cc1 differ by one ring position and are different compounds.

The editor is fetched once, on the first click, from its own GitHub release
(about 35 MB, ~30 MB kept) into $DSH_HOME/plugins/synomega/ketcher/<version>/,
verified against a pinned SHA-256, and then served by this harness. Serving it locally
is what makes it same-origin — the dialog reads the drawn structure directly, and the
editor keeps working with the network off. Nothing is downloaded until someone opens it.

Set ketcher.prefetch: true to fetch it during activation instead, ketcher.url to
point at a mirror or a file:// copy, or ketcher.enabled: false to leave the button
out entirely. Compositions with no web server (headless, CLI) never register the route.

Visualisation

The browser half registers a view for each tool on the harness's keyed
tool.call.toolview slot, so results render as cards inside the conversation:

• retro / forward — each candidate drawn as reactants → product with its score
• plan — the route as a tree, molecules at the nodes and reaction scores on the
  edges, purchasable and unpurchasable starting materials distinguished, selectable
  when several routes were found
• score — the SynScore with the route it came from
• evolve — molecules laid out by depth, each with its cumulative score

Depictions come from smiles-drawer;
tree layout from d3-hierarchy. Both are bundled,
so the page fetches nothing. A SMILES that will not parse falls back to its text rather
than an empty box, and a truncated tree says so — a clipped route must never read as a
complete one.

Cards are drawn purely from metadata persisted on the tool result, so reopening an old
conversation reproduces the same picture. Deployments without the browser UI (headless,
CLI) get the text rendering; no information is lost, only the drawing.

Forward prediction

Acetic acid and methanol, ranked five deep. Methyl acetate takes 0.9308 and the rest are
three orders of magnitude behind — the model reads that as Fischer esterification and
says so. Note the disambiguation in its answer: CO is methanol, not carbon monoxide
(C#O), which is exactly the class of mistake the composer's molecule editor exists to
prevent.

Multi-component evolution

Butanone, urea, and benzaldehyde evolved forward into 450 molecules over 683 reaction
edges, laid out by depth with each molecule's cumulative score. Depth 0 is what you put
in; everything to the right is what the network reached.

Configuration

All values are set in cordis.yml. The ones worth knowing:

How it works

browser   card renderers on tool.call.toolview  (smiles-drawer, d3-hierarchy)
   ^        drawn from the tool result's persisted metadata
          a composer seat on conversation.input.left  (Ketcher, in a same-origin frame)
   ^        HTTP, /dsh-synomega/ketcher
host      one Cordis plugin: five tools + prompt section + provisioning + that route
   ^        ndjson over stdin/stdout
python    one resident worker holding the loaded models

The Python worker is resident because loading SynOmega's models takes seconds; paying
that per call would make route planning unusable. Requests are handled one at a time —
inference is not thread-safe, and concurrency would only make each caller slower.

Known limitations

• A running prediction cannot be interrupted. Python inference offers no safe
  cancellation point, so a cancelled call settles immediately and its eventual result is
  discarded. If an abandoned call has not returned within hardKillMs, the worker is
  killed and restarted.
• Predictions are ranked candidates, not guarantees. Forward top-1 accuracy is about
  0.64 on the benchmark; routes are proposals, not validated procedures.
• The first call downloads a few hundred megabytes. In air-gapped, metered, or
  reproducibility-critical environments, pre-fetch with scripts/setup.mjs and treat the
  download as an explicit opt-in.
• The molecule editor is one more download. Ketcher ships as a 30 MB browser
  application; it is fetched on first use rather than vendored, so a fresh install pays
  for it once and an air-gapped one needs ketcher.url pointed at a local copy.
• Retrosynthesis is dual-use. The prompt section defers judgment about hazardous,
  controlled, or weaponizable targets to the deployment's own safety policy; this plugin
  does not itself decide what is permissible.

Licence

MIT.