Coda Overview — connectome analysis for neuPrint, CAVE, CATMAID

The analyses come with it

The standard connectome analyses are chains of nodes rather than scripts you have to write: partner tables, morphological similarity, clustering by connectivity, influence scores and path searches. Each is a just handful of nodes — including support for cross-dataset comparisons.

Who talks to whom

Connectivity fetches synaptic partners one or more hops out and hands back two things: the edge list, and the neuron set it reached. Adjacency takes that set onto itself — synapse counts from one group of neurons onto another, grouped by cell type if you want it — which is a matrix, so the Heatmap is the next card and nothing in between needs configuring.

Find Neurons Neurons Connectivity Neuron Set Adjacency Matrix Heatmap

For a bird's eye view: Neuron Profile answers the same question for one neuron or one cell type — inputs, outputs, regions and transmitters on a single card, fetching for itself.

Morphological clustering

NBLAST scores neurons, all‑by‑all or query‑target. Linkage turns the score matrix into a tree, and the Dendrogram hands a clade you click back out as a neuron set — so the clustering stays something you can steer rather than a number you have to accept.

Skeletons Skeletons NBLAST Scores Linkage Tree Dendrogram

Across datasets: drop Transform Neurons in after the skeletons to bridge each dataset into one template space — JRC2018 unisex, say — so the comparison is between shapes rather than between coordinate frames. Mirror Neurons is the left/right version of the same move.

Connectivity-based clustering

Partner Vectors turns each neuron's connectivity into a feature vector and Similarity Matrix scores every pair against every other — cosine, Pearson, Jaccard or Euclidean. From there it is the same Linkage as above, and Cut Tree hands the groups back as an ordinary table you can join onto anything.

Connectivity Connections Partner Vectors Vectors Similarity Matrix Matrix Linkage Tree Dendrogram

Use Cut Tree to create clusters from the linkage or Embedding to produce a 2D embedding that you can plug into a scatter plot. Across datasets: Match Cell Types derives the correspondence between two connectomes' type names first, so both datasets' vectors are written on one shared feature axis.

Incluence metrics & path analyses

Influence runs the influence score of Bates et al. — r = (I − gW)⁻¹s, walked to a hop budget, so what comes back is that score truncated rather than approximated, with the unwalked tail reported as a number rather than a caveat.

Influence Influence Bar Chart

Paths is the other half: every route from your sources to your targets within N hops, ranked by its weakest link, optionally collapsing neurons to cell types on the way. It comes out as a network, so the viewer is already wired.

Paths Network Network Viewer

The chip's colour is the node's category, exactly as on a card; the line between two chips is the value that flows along it, named and typed the way its socket is. Every one of these is a real node — the page is checked against the registry, so a renamed node is a failing test rather than a stale figure.

Build a dashboard

A pipeline defines the individual steps. A dashboard boils it down to the essential elements. When you press D, the canvas transforms into a grid where you can lay out the most important nodes.

Pick any nodes off the graph and arrange them: drag to reorder, drag a corner to resize. Cells stay live: sort the table, rotate the scene, tick a neuron in Explore and watch the others follow.

The layout is saved with the workflow, so a shared link can open straight into the dashboard rather than the canvas behind it.

Dashboard · 3 of 11 nodes Columns 2 ← Canvas

Explore Dataset24,918 neurons

LC

Neuroglancer3 segments

Table3 rows × 5 col

bodyIdtypeside 10021LC4L 10847LC6R 11309LC4R

Explore top left, its selection as a table below, and the same neurons in Neuroglancer down the right — the dashboard the Build a dashboard guide ends on. Tick a neuron in Explore and the other two follow.

Support for (almost) every major connectome today

Coda doesn't host any data itself. Instead, it lets you connect to and query the original data sources.

neuPrint

For example, MaleCNS, MANC, Hemibrain plus any other deployment by URL.

CAVE

For example, FlyWire FAFB public, BANC public and MICrONS Minnie65 public, plus any other datastack by name.

CATMAID

For example, the manually traced FAFB, FANC and larval L1 datasets hosted by Virtual Fly Brain. Or connect to your own CATMAID instance!

Your own data

Bring in your own data, e.g. annotations from SeaTable, Google Sheets, or CSV files (Upload Table + Table from URL).

Backends and datasets differ in what they provide. Coda will tell you if a dataset does not support e.g. shortest path queries.

Connections tokens stay in this browser

neuPrint CAVE CATMAID Annotations

connected · 6 datasets listed

Hemibrainv1.2.1

MaleCNSv1.0

MANCv1.2.3

Optic Lobev1.1

FIB-19v1.0

Mushroom Bodyno version

Interactive Exploration

Data viewers allow manually selecting neurons, enabling highly interactive pipelines.

Lasso points in a scatter, click nodes in a network, select a clade in a dendrogram. The picked rows leave by a Selected output. Pass the selection to other widgets — a 3D view, a fetch, another chart, or an embedded neuroglancer scene.

Scatter Plot· pre × post ⇧drag to lasso

Table1,704 rows, unchanged

Selected6 rows

Neuroglancer· hemibrain:v1.2.1 6 segments

the dataset’s published scene, with the selection written into it copy link

Exporting Data & Results is Easy

Any node’s result can be downloaded.

From the card

The ⤓ in a card’s footer writes what that node is holding. A viewer also exports its picture — re-drawn as vector, so an SVG opens in Illustrator or Inkscape.

Or as a step

A Download node at the end of a chain writes its file on every run. It passes its input through, so it drops in anywhere.

Formats the next tool reads

Tables as CSV, morphology as SWC and OBJ, networks as GraphML, trees as Newick, charts as SVG or PNG.

Download⤓

Tables and matrices

CSV JSON wide CSV

Morphology

SWC OBJ

Graphs and trees

GraphML nodes + links CSV Newick

Figures

SVG PNG

one file per neuron for a skeleton set capped at 50

Convert Pipelines to Python/R

Save ▸ Export as Jupyter Notebook, or as R Markdown. The graph is walked in dependency order and written out as code on the libraries the field already uses — neuprint-python, pandas and navis, or neuprintr, dplyr, nat and ggplot2.

LC-outputs.ipynb neuprint-python · pandas · navis

# Connectivity — downstream partners, one hop from neuprint import ( Client, NeuronCriteria, fetch_neurons, fetch_adjacencies, merge_neuron_properties, ) hemibrain = Client( "neuprint.janelia.org", dataset="hemibrain:v1.2.1" ) find_neurons, _ = fetch_neurons( NeuronCriteria(type=r"^LC\d+$", regex=True, status="Traced"), client=hemibrain, ) neurons, conns = fetch_adjacencies( find_neurons["bodyId"].tolist(), None, client=hemibrain ) connectivity = merge_neuron_properties(neurons, conns, ["type"]) group_by = ( connectivity.groupby("postType", dropna=False)["weight"] .sum() .reset_index(name="sum_weight") )

▶cell 4 of 9· one Client per dataset node

LC-outputs.Rmd neuprintr · dplyr · nat · ggplot2

```{r connectivity} library(neuprintr); library(dplyr) hemibrain <- neuprint_login(dataset = "hemibrain:v1.2.1") find_neurons <- coda_neurons(neuprint_search( "^LC\\d+$", field = "type", conn = hemibrain )) connectivity <- neuprint_connection_table( find_neurons$bodyId, prepost = "POST", conn = hemibrain ) group_by_df <- connectivity |> group_by(postType) |> summarise(sum_weight = sum(weight), .groups = "drop") ```

▶chunk 4 of 9· never a variable named filter

Runnable, and meant to be edited. Where Coda and the target library genuinely differ the cell says so in a note, and the generated code is checked in CI against the real installed libraries: syntax, undefined names, and whether an attribute actually resolves. A neuPrint graph exports to both languages; a CAVE graph exports to Python, on caveclient.

AI-enabled

Built-in assistant

Ask for a workflow in plain language and the assistant builds it: the nodes, the wires between them and the parameters, applied to the canvas as one step.

Four providers

Anthropic, OpenAI, Gemini, or Ollama against a model running on your own machine. Keys are pasted once and stay in this browser.

Or your own client

Coda’s MCP server lets Claude, ChatGPT and the rest build a workflow for you and hand back a link that opens it here.

Assistantclaude-sonnet-5

What do LC4 neurons talk to? Group it by cell type and chart it.

Four nodes onto the Hemibrain dataset already on your canvas.

addFind Neurons · type ^LC4$ · status Traced

addConnectivity · direction downstream · hops 1

addGroup By · by postType · agg sum(weight)

addBar Chart

wireHemibrain ▸ Dataset → Find Neurons ▸ Dataset

wireFind Neurons ▸ Neurons → Connectivity ▸ Neurons

wireConnectivity ▸ Table → Group By ▸ Table

wireGroup By ▸ Table → Bar Chart ▸ Table

Apply 8 changes Discard

Anthropic OpenAI Gemini Ollama · local

Shareable workflows

As a file

Download the workflow as a .coda.json — plain JSON for a repository, a supplement or an email. It stores the pipeline, not the results.

As a link

Or share a URL with the whole graph packed into its fragment, neuroglancer-style. No server, no account, nothing to expire. Large workflows go to a GitHub Gist instead.

Share workflow1,743 characters

navis-org.github.io/coda/#!c1.eNqNVFtv2jAU_itHedqkQAmXQnmr1E6bt… Copy

.coda.json LC-outputs.coda.json 14 kB

the pipeline, not the results · no token, no uploaded rows or edge sets

Coda — Feature Overview

Node-Based Editor