Tutorials

• 1: VFB Model Context Protocol (MCP) Tool Guide
• 2: Application Programming Interfaces (APIs)
• 2.1: Guide to Working with Images from Virtual Fly Brain (VFB) Using the VFBConnect Library
• 2.2: Hacking the connectome
• 2.2.1: Tool landscape
• 2.2.2: Introduction to connectomic data and tools
• 2.2.3: Discovery
• 2.2.4: Mapping
• 2.2.5: Visualisation
• 2.2.6: Connectomics
• 2.2.7: NBLAST
• 2.3: Downloading Images from VFB Using VFBconnect
• 2.4: VFB connect API overview
• 2.5: SOLR search example
• 2.6: Data types
• 2.7: Plotting
• 2.8: pymaid
• 2.9: NBLAST
• 2.10: neuprint

1 - VFB Model Context Protocol (MCP) Tool Guide

Overview

The Virtual Fly Brain Model Context Protocol (MCP) Tool enables you to query VFB data through Large Language Models like Claude using natural language. This guide shows you how to get started and provides examples of common queries.

What is MCP?

The Model Context Protocol is a standard that allows LLMs to interact with external data sources and tools. The VFB MCP tool follows this standard, providing your LLM with access to VFB’s neuroanatomical databases, NBLAST similarity scores, and term information.

Accessing the Tool

The VFB MCP tool is available at: vfb3-mcp.virtualflybrain.org

Quick Start

Use the Live Service (Recommended)

The easiest way to use VFB3-MCP is through our hosted service. This requires no installation or setup on your machine.

Claude Desktop Setup

1. Open Claude Desktop and go to Settings
2. Navigate to the MCP section
3. Add a new MCP server with these settings:
   • Server Name: virtual-fly-brain (or any name you prefer)
   • Type: HTTP
   • Server URL: https://vfb3-mcp.virtualflybrain.org

Configuration JSON (alternative method):

{
  "mcpServers": {
    "virtual-fly-brain": {
      "type": "http",
      "url": "https://vfb3-mcp.virtualflybrain.org",
      "tools": ["*"]
    }
  }
}

Claude Code Setup

1. Locate your Claude configuration file:
   • macOS/Linux: ~/.claude.json
   • Windows: %USERPROFILE%\.claude.json
2. Add the VFB3-MCP server to your configuration:

{
  "mcpServers": {
    "virtual-fly-brain": {
      "type": "http",
      "url": "https://vfb3-mcp.virtualflybrain.org",
      "tools": ["*"]
    }
  }
}

3. Restart Claude Code for changes to take effect

GitHub Copilot Setup

1. Open VS Code with GitHub Copilot installed
2. Open Settings (Ctrl/Cmd + ,)
3. Search for “MCP” in the settings search
4. Find the MCP Servers setting
5. Add the server URL: https://vfb3-mcp.virtualflybrain.org
6. Give it a name like “Virtual Fly Brain”

Alternative JSON configuration (in mcp.json):

{
  "servers": {
    "virtual-fly-brain": {
      "type": "http",
      "url": "https://vfb3-mcp.virtualflybrain.org"
    }
  }
}

Visual Studio Code (with MCP Extension)

1. Install the MCP extension for VS Code from the marketplace
2. Open the Command Palette (Ctrl/Cmd + Shift + P)
3. Type “MCP: Add server” and select it
4. Choose “HTTP” as the server type
5. Enter the server details:
   • Name: virtual-fly-brain
   • URL: https://vfb3-mcp.virtualflybrain.org
6. Save and restart VS Code if prompted

Other MCP Clients

For any MCP-compatible client that supports HTTP servers:

{
  "mcpServers": {
    "virtual-fly-brain": {
      "type": "http",
      "url": "https://vfb3-mcp.virtualflybrain.org",
      "tools": ["*"]
    }
  }
}

Gemini Setup

To use the Virtual Fly Brain (VFB) Model Context Protocol (MCP) server with Google Gemini, you can connect through custom Python/Node.js clients that support MCP.

Note: Direct Gemini web interface integration with MCP is not currently supported. Developer tools are needed to connect the two.

Option 1: Using Python

For application development, use the mcp and google-genai libraries to connect.

Setup: pip install google-genai mcp

Implementation: Use an SSEClientTransport to connect to the VFB URL, list its tools, and pass their schemas to the Gemini model as Function Declarations.

Testing the Connection

Once configured, you can test that VFB3-MCP is working by asking your AI assistant questions like:

Basic Queries:

• “Get information about the neuron VFB_jrcv0i43”
• “Search for terms related to medulla in the fly brain”
• “What neurons are in the antennal lobe?”

Advanced Queries:

• “Find all neurons that connect to the mushroom body”
• “Show me expression patterns for gene repo”
• “What brain regions are involved in olfactory processing?”
• “Run a connectivity analysis for neuron VFB_00101567”

Search Examples:

• “Search for adult neurons in the visual system”
• “Find genes expressed in the central complex”
• “Show me all templates available in VFB”

If you see responses with VirtualFlyBrain data, including neuron names, brain regions, gene expressions, or connectivity information, the setup is successful!

For more detailed usage examples and API calls, see examples.md.

Local Installation

If you prefer to run the MCP server locally, see the VFB3-MCP repository README for detailed installation instructions.

Core Features

The tool provides access to three main capabilities:

1. Term Information Queries (get_term_info)

Retrieve detailed information about any VFB term using its VFB ID.

Example Query:

"What is the medulla? Please get the full definition and structure."

Returns:

• Term definition and synonyms
• Classification and type information
• Anatomical relationships (part of, develops from, innervates, etc.)
• Associated neurons and expression patterns
• Related images and connectivity data

2. Term Search (search_terms)

Search for VFB terms using keywords and filters.

Example Query:

"Find neurons in the medulla"

Advanced Filtering Options:

• Filter by entity type: neuron, muscle, glia, anatomical region
• Filter by nervous system component: visual system, olfactory system, sensory neuron, motor neuron, etc.
• Filter by nervous system property: cholinergic, GABAergic, glutamatergic, dopaminergic, peptidergic, etc.
• Filter by dataset: FAFB, FlyCircuit, hemibrain, neuprint, flycircuit, etc.

3. Query Execution (run_query)

Execute specific queries on VFB terms, including NBLAST similarity analysis.

Example Query:

"What neurons are morphologically similar to IN02A049?"

Example Use Cases

Case 1: Exploring a Transgenic Construct

User Question: “What is P{E(spl)m8-HLH-2.61} and where is it used?”

Tool Actions:

1. Search for the construct in VFB
2. Retrieve full term information
3. Return detailed description including:
   • FlyBase ID (FBtp0004163)
   • Gene involved: E(spl)m8
   • Type: Transgenic construct (reporter for gene expression)
   • Expression patterns and research use
   • Related constructs and variants

Result: You get comprehensive information about the transgenic reporter, its purpose, and research applications.

Case 2: Understanding a Neuroblast Population

User Question: “What is the Medulla Forming Neuroblast and what role does it play?”

Tool Actions:

1. Search for “medulla forming neuroblast”
2. Get term info for FBbt_00001938
3. Return:
   • Cell type classification (neuroblast)
   • Location in the larval optic anlage
   • Developmental fate (produces medulla neurons)
   • Marker genes (dpn, ase)
   • Number of neurons produced (~54,000 secondary neurons)
   • Available scRNAseq and expression data

Result: Understand the neuroblast’s role in developing the adult medulla’s neural circuitry.

Case 3: Discovering Neuron Types

User Question: “What types of neurons are in the medulla?”

Tool Actions:

1. Search for “neuron” with filter for medulla
2. Return 472 neuron types with parts in the medulla, organized by category:
   • Medulla intrinsic neurons (Mi): columnar neurons with confined processes
   • Central medulla intrinsic neurons (Cm): arborizing in central/serpentine layer
   • Medulla tangential neurons (Mt): wide-field spanning neurons
   • Medulla visual projection neurons (MeVP): tangential projection neurons
   • Medulla columnar neurons (MC): connecting medulla to tubercle
   • Plus many more specialized types

Result: Get a comprehensive overview of medulla neuron diversity and organization.

Case 4: Morphological Similarity Queries

User Question: “Show me what the IN02A049 neuron looks like and find similar neurons.”

Tool Actions:

1. Get term info for IN02A049 (specific instance from MANC connectome)
2. Execute NBLAST query for morphologically similar neurons
3. Return:
   • 3D visualization of the neuron
   • Classification and properties
   • Synaptic inputs (neurotransmitter types and counts)
   • Morphologically similar neurons with NBLAST scores
   • Cross-connectome comparisons

Result: Discover morphologically similar neurons for comparative analysis.

Case 5: Understanding NBLAST Scores

User Question: “How are NBLAST scores calculated?”

Tool Actions:

1. Search for “NBLAST”
2. Return detailed explanation including:
   • Algorithm basis (Costa et al. 2016)
   • How neurons are represented (point skeletons with direction vectors)
   • Scoring mechanism (Euclidean distance + direction similarity)
   • Normalization approach (comparison to self-match)
   • Asymmetry property and symmetrical variants
   • Available datasets (FAFB-FlyWire, Male-CNS optic lobe, FlyCircuit, Hemibrain, FAFB-CATMAID)

Result: Understand the methodology behind VFB’s morphological similarity analysis.

Tips for Effective Queries

1. Use VFB IDs When Known

If you know the VFB ID of a term, use it directly:

"Get me detailed information about FBbt_00003748 (the medulla)"

2. Combine Search and Query

Use search first to find relevant terms, then query them:

"Find all cholinergic neurons in the visual system, 
then tell me about the top 5"

3. Filter Strategically

Use filters to narrow results:

"Show me motor neurons from the male-CNS optic lobe dataset"

4. Explore Relationships

Ask about anatomical and functional relationships:

"What neurons innervate the medulla? 
What brain regions do they come from?"

5. Cross-Dataset Comparisons

Compare neurons across different connectome datasets:

"Find the equivalent of this FAFB neuron in the hemibrain dataset"

Available Datasets

The VFB MCP tool provides access to neurons and data from:

• FAFB-FlyWire (v783) - Large-scale adult brain connectome
• Male-CNS optic lobe (v1.0.1) - Focused optic lobe connectome
• FlyCircuit (1.0) - Single-neuron morphology database
• Hemibrain (1.2.1) - Subset of adult brain connectome
• FAFB-CATMAID - Manually traced EM data
• FlyLight Split-GAL4 - Driver line expression images
• scRNAseq data - Transcriptomic information

Understanding VFB IDs

VFB terms use standardized identifiers:

• FBbt_ - Drosophila anatomy terms (e.g., FBbt_00003748 = medulla)
• FBgn_ - FlyBase genes (e.g., FBgn0000137 = ase gene)
• FBtp_ - FlyBase transgenic constructs (e.g., FBtp0004163 = P{E(spl)m8-HLH-2.61})
• VFB_ - VirtualFlyBrain-specific IDs for individuals and images

Next Steps

• Explore the tool: Visit vfb3-mcp.virtualflybrain.org
• Read more about NBLAST: See our NBLAST concepts page
• Learn about VFB APIs: Check our API overview
• Browse VFB directly: Visit the main Virtual Fly Brain site

Common Questions

Q: Do I need to install anything? A: No, if you’re using Claude or another MCP-compatible LLM with the integration already set up, just start asking questions.

Q: Can I download the data I find? A: Yes, many results include links to download images, neuron skeletons, and connectivity data. Check the API documentation for programmatic access.

Q: What if I don’t know the VFB ID? A: The search tool can find terms by name or keyword. The LLM will help you locate the right term.

Q: Can I combine VFB queries with other analyses? A: Absolutely! You can ask your LLM to retrieve VFB data and then perform additional analyses, create visualizations, or integrate with other tools.

Happy exploring! If you have questions or suggestions about the VFB MCP tool, please reach out to the VFB team.

2 - Application Programming Interfaces (APIs)

2.1 - Guide to Working with Images from Virtual Fly Brain (VFB) Using the VFBConnect Library

Prerequisites

Before starting, ensure you have the VFBConnect library installed. The recommended Python version is 3.10.14, as this version is tested against the library.

pip install vfb-connect

Importing the VFBConnect Library

Start by importing the VFBConnect library. This library provides a simple interface to interact with neuron data from the Virtual Fly Brain.

from vfb_connect import vfb

Retrieving Neuron Data

To work with specific neurons, you can use the vfb.term() function. This function takes a unique identifier (e.g., ID, label, synonym) for the neuron.

Example: Retrieving a Single Neuron

neuron = vfb.term('5th s-LNv (FlyEM-HB:511051477)')

The neuron variable now holds data about the neuron identified by the given term.

Working with Neuron Data

The retrieved neuron object can provide different representations of neuron data, such as its skeleton, mesh, and volume. These representations can be visualized using various plotting methods.

# Access the skeleton representation
neuron_skeleton = neuron.skeleton

# Check the type of the skeleton representation
print(type(neuron_skeleton))  # Output: <class 'navis.neuron.Neuron'>

# Plot the skeleton in 2D
neuron_skeleton.plot2d()

# Access the mesh representation
neuron_mesh = neuron.mesh

# Access the volume representation
neuron_volume = neuron.volume

Retrieving Multiple Neurons

You can retrieve multiple neurons using the vfb.terms() function, which accepts a list of neuron identifiers.

Example: Retrieving Multiple Neurons

neurons = vfb.terms(['5th s-LNv', 'fru-M-300008', 'catmaid_fafb:8876600'])

This command retrieves multiple neurons, which can then be visualized or manipulated collectively.

Flexible Matching Capabilities

One of the key features of the VFBConnect library is its flexible matching capability. The vfb.terms() function can accept a variety of identifiers, such as:

• IDs: Unique identifiers assigned to each neuron.
• Xref (Cross-references): External references that relate to other datasets.
• Labels: Human-readable names for neurons.
• Symbols: Abbreviated names or symbols used to represent neurons.
• Synonyms: Alternative names by which a neuron might be known.
• Partial Matching: You can provide a partial name, and VFBConnect will attempt to find the best match.
• Case Insensitive Matching: Matching is case insensitive, so if an exact match isn’t found, ‘5th s-LNv’ and ‘5TH S-LNV’ are treated the same. This allows for more flexible querying without worrying about exact case matching.

Example: Using Flexible Matching

neurons = vfb.terms('5th s-LN')

If an exact match isn’t found, VFBConnect will provide potential matches. This feature ensures that even with partial or approximate information, you can still retrieve the relevant neuron data.

Output Example:

Notice: No exact match found, but potential matches starting with '5th s-LN': 
'5th s-LNv (FlyEM-HB:511051477)': 'VFB_jrchk8e0', 
'5th s-LNv': 'VFB_jrchk8e0'

This notice will help you identify the correct neuron based on the closest matches.

Visualizing Neurons

VFBConnect provides various methods to visualize neuron data, both individually and collectively.

3D Visualization

To plot neurons in 3D, use the plot3d() method. This is useful for visualizing the spatial structure of neurons.

neurons.plot3d()

2D Visualization

For 2D visualization, use the plot2d() method.

neurons.plot2d()

Viewing Merged Templates

VFBConnect also allows viewing merged templates of neurons, combining multiple neuron structures into a single view.

neurons.show()

Opening Neurons in VFB

To open the neurons directly in Virtual Fly Brain, use the open() method. This will launch a browser window displaying the neurons in the VFB interface.

neurons.open()

Summary

• Use vfb.term() to retrieve single neuron data.
• Use vfb.terms() to retrieve multiple neurons with support for partial, case-insensitive, and flexible matching (IDs, labels, symbols, synonyms, etc.).
• Access different data representations (skeleton, mesh, volume) via neuron objects.
• Visualize neuron data in 2D and 3D.
• Use the show() method to view merged neuron templates.
• Open neuron data directly in Virtual Fly Brain with the open() method.

These examples provide a foundation for working with neuron data from Virtual Fly Brain using the VFBConnect library. By exploring different neuron representations and visualization methods, you can analyze and understand neuron structures more effectively.

2.2 - Hacking the connectome

Below you can watch the recorded introduction session of our workshop and follow along with the workshop notebooks we work through to show examples of how you can use the available {{ ref “tools.md” tools }} to explore and analyse the published connectomes available on VFB.

2.2.1 - Tool landscape

Below are brief descriptions of the libraries/packages. For details, I defer to their respective (excellent) documentations.

Querying VFB

Queries against VFB’s REST API are easiest with vfb_connect for Python. For R there is a vfb_connect wrapper, vfbconnectr. See also David’s presentation for details.

R

In R, the natverse is your one-stop-shop for all things neuron: it’s a collection of various R packages that are built on top of the neuroanatomy toolbox, nat. Of particular relevance for this workshop:

1. nat is a general purpose library for working with morphological neuron data. In this workshop, we make heavy use of nat’s plotting capabilities but its capabilities extend far beyond that. If you want to run any morphological analysis, I highly recommend you have a look at the “Articles” in nat’s doc.
2. neuprintr and hemibrainr provide an interface with neuprint and the Janelia hemibrain dataset (link). The former lets you run queries against neuprint’s neo4j database while the latter contains meta data and various convenience functions to work with the hemibrain dataset.
3. rcatmaid provides an interface with CATMAID servers such as those the VFB uses to host published from the FAFB or larval fruit fly dataset. rcatmaid is built on top of nat and you can use nat functions with neurons pulled via rcatmaid.

Python

In Python, we find packages analogous to those in R:

1. navis is nat’s serpentine sibling: a general purpose neuron library for visualization and analysis of neuronal morphologies. It also features interfaces e.g. with Blender 3D and the natverse via rpy2.
2. python-neuprint is a Python library to interface with neuprint maintained by Janelia. Note that navis wraps this library and adds some convenience functions. See this tutorial.
3. pymaid lets you interface with CATMAID servers. Critically, it’s built on top of navis and you can natively use navis functions with pymaid neurons. Note that due to a name clash the library is called python-catmaid on PyPI.

Noteworthy mentions

There are a few more packages/functions that you might hear of over the course of the workshop.

NBLAST

NBLAST is an algorithm that computes morphological similarity between neurons (Costa et al., 2016). This has proven incredibly useful to find similar neurons across datasets but also to cluster neurons into cell types.

On the R side the algorithm is implemented in nat.nblast and in Python it is part of navis (see this tutorial).

Transforms

You will note that neurons pulled from VFB are typically in the same template space which makes co-visualization of neurons from different datasets a breeze. If you want to transform spatial data between template brains, e.g. from FAFB (“FAFB14”) to hemibrain (“JRCFIB2018F”), you should look for nat.flybrains & nat.jrcbrains in R and navis-flybrains in Python.

2.2.2 - Introduction to connectomic data and tools

2.2.3 - Discovery

Required packages: vfb-connect and python-catmaid (pymaid & navis)

!pip install vfb-connect --upgrade
!pip install python-catmaid --upgrade

A note on using these notebooks

This is designed as an interactive tutorial. Feel free to add code cells below each example to try out variations of your own.

How to find neurons across datasets

VirtualFlyBrain integrates images and connectomics profiles of neurons from many sources. It classifies and records their properties using a standard, queryable classification (The Drosophila Anatomy Ontology). This standardises the names of neuron types across sources, so you don’t need to worry about differences in nomenclature uses and supports queries for neurons by their classification.

# Import libs and initialise API objects
from vfb_connect.cross_server_tools import VfbConnect
import pandas as pd
vc = VfbConnect()

import pymaid
import navis

navis.set_pbars(jupyter=False)
pymaid.set_pbars(jupyter=False)

# Connect to the VFB CATMAID server hosting the FAFB data
rm = pymaid.connect_catmaid(server="https://fafb.catmaid.virtualflybrain.org/", api_token=None, max_threads=10)

# Test call to see if connection works 
print(f'Server is running CATMAID version {rm.catmaid_version}')

WARNING: Could not load OpenGL library.
INFO  : Global CATMAID instance set. Caching is ON. (pymaid)
Server is running CATMAID version 2020.02.15-905-g93a969b37

Finds neurons by type (classification) across datasets

We can use the vc.get_instances method in combination with the name of a neuron type on VFB to find individual neurons from multiple sources.

Use the search tool on VFB to find neuron types by name or synonym:

Use either the full name or the Symbol to query for neurons:

DA3adPN = vc.get_instances("adult Drosulfakinin neuron", summary=True)
pd.DataFrame.from_records(DA3adPN)

Find neurons by location

We can use the same method to search for neurons by location, using simple queries.

# Find neurons by location. The following query works across multiple data sources and both sides of the brain.  
# Results may be incomplete & may include minor overlap inferred from low synapse counts

neurons_in_DA3 = vc.get_instances("'neuron' that 'overlaps' some 'antennal lobe glomerulus DA3'", summary=True)
neurons_in_DA3_tab = pd.DataFrame.from_records(neurons_in_DA3)
neurons_in_DA3_tab[0:5]

Running query: FBbt:00005106 that RO:0002131 some FBbt:00003934
Query URL: http://owl.virtualflybrain.org/kbs/vfb/instances?object=FBbt%3A00005106+that+RO%3A0002131+some+FBbt%3A00003934&prefixes=%7B%22FBbt%22%3A+%22http%3A%2F%2Fpurl.obolibrary.org%2Fobo%2FFBbt_%22%2C+%22RO%22%3A+%22http%3A%2F%2Fpurl.obolibrary.org%2Fobo%2FRO_%22%2C+%22BFO%22%3A+%22http%3A%2F%2Fpurl.obolibrary.org%2Fobo%2FBFO_%22%7D&direct=False
Query results: 158

# Find local interneurons (intrinsic neurons) of the AL, overlapping DA3:

local_in_DA3 = vc.get_instances("'local interneuron of adult antennal lobe' that 'overlaps' some 'antennal lobe glomerulus DA3'",
                                summary=True)
local_in_DA3_tab = pd.DataFrame.from_records(local_in_DA3)
local_in_DA3_tab

Running query: FBbt:00007390 that RO:0002131 some FBbt:00003934
Query URL: http://owl.virtualflybrain.org/kbs/vfb/instances?object=FBbt%3A00007390+that+RO%3A0002131+some+FBbt%3A00003934&prefixes=%7B%22FBbt%22%3A+%22http%3A%2F%2Fpurl.obolibrary.org%2Fobo%2FFBbt_%22%2C+%22RO%22%3A+%22http%3A%2F%2Fpurl.obolibrary.org%2Fobo%2FRO_%22%2C+%22BFO%22%3A+%22http%3A%2F%2Fpurl.obolibrary.org%2Fobo%2FBFO_%22%7D&direct=False
Query results: 53

# Find neurons by dataset/paper - on CATMAID

bates = pymaid.find_neurons(annotations='Paper: Bates and Schlegel et al 2020')
bates

INFO  : Found 583 neurons matching the search parameters (pymaid)

# Inspect what datasets are available on VFB

ds = vc.neo_query_wrapper.get_datasets(summary=True)
ds_tab = pd.DataFrame.from_records(ds)
ds_tab.sort_values(by=['id'])

sayin_tab = pd.DataFrame.from_records(vc.get_instances_by_dataset('Sayin2019', summary=True))
sayin_tab

vc.get_connected_neurons_by_type(upstream_type='LNd', downstream_type='adult descending neuron', weight=20)

# Intra pacemaker neuron neuron connections

vc.get_connected_neurons_by_type(upstream_type='pacemaker neuron', downstream_type='pacemaker neuron', weight=20)

vc.get_connected_neurons_by_type(upstream_type='adult neuron', downstream_type='adult Drosulfakinin neuron', weight=20)

2.2.4 - Mapping

!pip install vfb-connect --upgrade

# Import libs and initialise API objects
from vfb_connect.cross_server_tools import VfbConnect
import pandas as pd

vc = VfbConnect()

import pymaid
import navis

navis.set_pbars(jupyter=False)
pymaid.set_pbars(jupyter=False)

# Connect to the VFB CATMAID server hosting the FAFB data
rm = pymaid.connect_catmaid(server="https://fafb.catmaid.virtualflybrain.org/", api_token=None, max_threads=10)

# Test call to see if connection works 
print(f'Server is running CATMAID version {rm.catmaid_version}')

# Many functions return JSON-compatible nested data structures. This function coverts them to DataFrame.
def summary_2_df(summary, sort=None):
    """Convert summary to DataFrame.  Optionally specify a set of columns to sort as a list of strings"""
    if sort:
        return pd.DataFrame.from_records(summary).sort_values(sort)
    else:
        return pd.DataFrame.from_records(summary)

WARNING: Could not load OpenGL library.
INFO  : Global CATMAID instance set. Caching is ON. (pymaid)
Server is running CATMAID version 2020.02.15-925-gf56795c9c

Mapping

Use case: If I have a single neuron, how can I find other neurons of the same or similar type within or between data sources?

Mapping via common parent type

# lets take some examples from a discovery query on the previous spreadhseet
sayin_tab = pd.DataFrame.from_records(vc.get_instances_by_dataset('Sayin2019', summary=True))
sayin_tab

oct_VPM3 = summary_2_df(vc.get_instances('octopaminergic VPM3 neuron', summary=True))
oct_VPM3

oct_VPM3_images = vc.neo_query_wrapper.get_images(oct_VPM3['id'], stomp=True, template='JRC2018Unisex', image_folder = 'oct_VPM3b')
oct_VPM3_images

oct_VPM3_images = vc.get_images_by_type('octopaminergic VPM3 neuron', stomp=True, template='JRC2018Unisex', image_folder = 'oct_VPM3')
nl = navis.read_swc('./oct_VPM3')
navis.plot3d(nl)

Running query: FBbt:00110151
Query URL: http://owl.virtualflybrain.org/kbs/vfb/instances?object=FBbt%3A00110151&prefixes=%7B%22FBbt%22%3A+%22http%3A%2F%2Fpurl.obolibrary.org%2Fobo%2FFBbt_%22%2C+%22RO%22%3A+%22http%3A%2F%2Fpurl.obolibrary.org%2Fobo%2FRO_%22%2C+%22BFO%22%3A+%22http%3A%2F%2Fpurl.obolibrary.org%2Fobo%2FBFO_%22%7D&direct=False
Query results: 3