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 just a handful of nodes — including support for cross-dataset comparisons.

Who talks to whom

Connectivity fetches synaptic partners one or more hops out. It gives you the edge list and the set of neurons it reached. Adjacency turns that set into a matrix of synapse counts between the neurons (optionally grouped by cell type), which you can plug straight into a Heatmap.

Find Neurons Neurons Connectivity Neuron Set Adjacency Matrix Heatmap

For a bird's eye view: Neuron Profile shows the inputs, outputs, brain regions and transmitters of a single neuron or cell type on one card. It fetches its own data, so it needs nothing wired in.

Morphological clustering

NBLAST scores neurons, all‑by‑all or query‑target. Linkage turns the score matrix into a tree, and the Dendrogram draws it. Click a clade in the dendrogram to pass those neurons on to the next node.

Skeletons Skeletons NBLAST Scores Linkage Tree Dendrogram

Across datasets: drop Transform Neurons in after the skeletons to move each dataset into the same template space (e.g. JRC2018 unisex) before you compare them. Mirror Neurons does the same for the left and right side of the brain.

Connectivity-based clustering

Partner Vectors turns each neuron's connectivity into a feature vector and Similarity Matrix compares every pair of neurons using cosine, Pearson, Jaccard or Euclidean distance. From there you use the same Linkage as above.

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 works out which cell types correspond between two connectomes, so that the partner vectors from both datasets can be compared directly.

Influence metrics & path analyses

Influence calculates the influence score from Bates et al., r = (I − gW)⁻¹s, up to a maximum number of hops. The node also tells you how much of the score lies beyond that cut-off.

Influence Influence Bar Chart

Paths finds every route from your sources to your targets within N hops and ranks them by their weakest link. Neurons can optionally be collapsed into cell types. The result is a network you can open in the Network Viewer.

Paths Network Network Viewer

Each chip is coloured by the node's category, the same as on the canvas. The label between two chips is the output that connects them. All of these are real nodes you can find in the node browser.

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.

Dashboard · 3 of 11 nodes Columns 2 ← Canvas

Explore Dataset24,918 neurons

LC

Neuroglancer3 segments

Table3 rows × 5 col

bodyIdtypeside 10021LC4L 10847LC6R 11309LC4R

Explore Dataset at the top left, its selection as a table below, and the same neurons in Neuroglancer on the right. This is the dashboard you end up with in the Build a dashboard guide.

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

Click the ⤓ in a card’s footer to download that node’s result. Viewers can also export their plot as SVG, which you can edit in Illustrator or Inkscape.

Or as a step

Add a Download node at the end of a chain to write a file on every run. It passes its input through, so you can also put it in the middle of a chain.

Formats

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

Use Save ▸ Export as Jupyter Notebook (or R Markdown) to turn a workflow into code. It uses the usual libraries: neuprint-python, pandas and navis for Python, and neuprintr, dplyr, nat and ggplot2 for R.

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

The exported code runs as is, and you can edit it from there. If the library does something differently from Coda, a note in the cell tells you. We test the generated code against the actual libraries. neuPrint workflows export to both Python and R; CAVE workflows export to Python only (using caveclient).

AI-enabled

Built-in assistant

Describe what you want in plain language and the assistant builds the workflow for you: nodes, connections and parameters. You can review the changes before applying them.

Four providers

Anthropic, OpenAI, Gemini, or Ollama for a model running on your own machine. API keys are stored in your browser.

Or your own client

With Coda’s MCP server, Claude, ChatGPT and other clients can build a workflow and give you a link that opens it in Coda.

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 file. It's plain JSON, so you can put it in a repository, a supplement or an email. It contains the pipeline but not the results.

As a link

Or share a URL that contains the whole workflow, similar to neuroglancer links. Nothing is stored on a server, so the link doesn't expire. Large workflows can be shared via 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