Display an interactive graph visualization of the given [entries](/entry/term-entry).

Lookup Function

# Details

This function will display an interactive graph of the specified entries. Up to 5,000 entries can be displayed initially. If the included entries have relationships to other entries, "placeholder" nodes will be shown in the graph, which you can then click on to display those entries as well. This process can continue indefinitely, adding more and more entries to the graph interactively.

For details on how the graph layout algorithm works, see the blog post {entry("improving-our-graph-visualization").link()}.

## Arguments

First argument: an [Entry](/entry/term-entry) or a set of [Entries](/entry/term-entry) that we want to visualize interactively.

## Examples

1. **Graph of a few specific entries**:  
   {lookupDemo(
      [entry("demo-moose"), entry("demo-elk"), entry("demo-deer") ].graph()
   )}

2. **Graph of all entries of particular Entry Types**:  
   {lookupDemo(
      allEntries().filter(entryType=[entryType("demo-species"), entryType("demo-family"), entryType("demo-class")]).graph()
   )}

3. **Graph of all entries related to a particular entry**:  
   {lookupDemo(
      graph( entry("set-rel-fns").andRelated() )
   )}


4. **Graph of all entries**:  

    This isn't a particularly useful example for Neolace Junction because so many entries don't have relationships to each other.
    On other datasets it can be very useful.

   {lookupDemo(
      allEntries().graph()
   )}

Details

graph()

Functions related to getting a property value.

Get property functions

Format the given text using Markdown, to add **bold**, *italics*, links, or other formatting.

markdown()

A **property** is an attribute that specific [entries](/term/entry) can have, that provides a piece of information about each such entry in a consistent way. For example, an entry about "Canada" would state that it has a **Total Area** of "9,984,670 km^2^" - in this case, "Total Area" is the Property and "9,984,670 km^2^" is the [Property Value](/entry/term-property-value).

Property

The node types and relationships that Neolace uses within Neo4j to represent a Neolace Site and all of its content.

002 Graph Data Model

An introduction to Neolace: what it is and how it works

Introduction to Neolace

Given an [entry](/entry/term-entry), this will return all directly related entries (via any type of relationship) *and* the entry itself. It's often used with { entry("lookup-graph") } to generate graphs of everything related to a particular entry.

andRelated()

An overview of the software architecture of Neolace.

001 Architecture of Neolace

A **draft** is a set of proposed edits that haven't yet been applied/published. Each draft can include edits to [entries](/entry/term-entry) and/or to the site's [schema](/entry/term-schema). Drafts are usually used to allow another person to review and comment on changes before they go live.

Draft

A screenshot of the graph visualization of selected TechNotes entries. This was generated using the lookup expression `entry("tc-ec-cell-li-cyl").andRelated().andDescendants().graph()`

Some TechNotes data graphed (newer Neolace version)

Every [Entry](/entry/term-entry) is of a specific **Entry Type**. The Entry Type determines what [properties](/entry/term-property) the entry can have (including what relationships to other entries it can have), as well as what type of content it can have (article text, image, attached files, etc.). This entry, { this }, has entry type { this.entryType() }. Entry Types are part of each [Site](/entry/term-site)'s [Schema](/entry/term-schema).

Entry Type

Given a list of entries, **slice()** can be used to select a portion of the list.

slice()

Returns the ancestors of the specified entry. Unlike {entry("lookup-andAncestors")}, the result will not include the entry itself.

ancestors()

Blog posts from our developers about their experience building Neolace.

Development Blog

The **elk** (*Cervus canadensis*), also known as the **wapiti**, is one of the largest species within the [deer family](/entry/demo-deer), Cervidae, and one of the largest terrestrial mammals in its native range of North America, as well as Central and East Asia. The common name "elk", used in North America, creates confusion because the larger *Alces alces*, which is called "moose" in North America, is also called "elk" in British English, and related names in other European languages (German Elch, Swedish älg, and French élan). The name "wapiti" is sometimes used in North America for *Cervus canadensis*. It originates from the Shawnee and Cree word waapiti, meaning 'white rump'.

Given a list of entries or other values, **sort()** will sort it according to the specified criteria.

sort()

Things we ❤️

A diagram showing the high-level [architecture of Neolace](/entry/x-001-architecture).

Architecture of Neolace (Diagram)

A **Site** in Neolace is a collection of knowledge or structured data. Each site has its own [Schema](/entry/term-schema) that defines what types of entries it has as well as the attributes and relationships that can exist for those entries. Each site also has its own collection of [Entries](/entry/term-entry) that comprise the actual content/data of the site. You are currently reading the **Neolace Junction** site at **junction.neolace.com**, which is part of the larger Neolace.com [Realm](/entry/term-realm).

Site

An Entry is the core concept in Neolace. Each Neolace site is a collection of Entries. Every Entry has a **name**, **description**, **[key](/entry/term-key)** (friendly ID), and [VNID](/entry/term-VNID) (permanent unique ID). Entries can also have **properties** (which can include relationships with other Entries) and **content** (like articles, images, or files). Every Entry is of exactly one Entry Type, which defines what properties and content that Entry can or must have.

Entry

Returns the descendants of the specified entry, *and* the entry itself.

andDescendants()

A Connector is a plugin for Neolace that can import data from an external system, on an ongoing basis. This makes the data from the external system available within Neolace, and keeps it updated in real time. Each such external data source that is integrated into a neolace site is called a **Connection**.

Connector

It turns out that writing a parser is... surprisingly easy with the right tool!

Parsing Lookup Expressions using Chevrotain

Counts the number of [entries](/entry/term-entry)/values in the given result. Returns a number.

count()

A VNID is the internal identifier for each object that Neolace uses. For example, every [Entry](/entry/term-entry) has a unique VNID, as does every Entry Type, every User, every Site, etc. A VNID is a type of [UUID/GUID](https://en.wikipedia.org/wiki/Universally_unique_identifier) encoded into a short string. As an example, the VNID of the entry that defines this term "VNID" in the documentation is { this.id }. Generally, VNIDs are only of interest for developers, and users will generally use [keys](/entry/term-key) instead.

VNID

Filter is used to reduce a set of entries to a smaller set, based on some criteria. For example, `allEntries().filter(entryType=`{ entryType("lookup-function") }`)` is used to show only entries that are "lookup functions" instead of showing all entries.

filter()

Get an [entry](/entry/term-entry), by [key](/entry/term-key) or [VNID](/entry/term-VNID).

entry()

The **grizzly bear** (*Ursus arctos horribilis*), also known as the "North American brown bear" or simply "grizzly", is a population or subspecies of the brown bear found in North America.

Grizzly bear

**get()** is used to retrieve [property values](/entry/term-property-value) from an entry or from a set of entries. It is the main way to find related entries using a specific relationship.

get()

The **moose** (in North America) is a member of the New World deer subfamily and is the largest and heaviest extant species in the deer family.

Moose

**Bears** are carnivoran mammals of the family Ursidae. Although only eight species of bears are extant, they are widespread, appearing in a wide variety of habitats throughout the Northern Hemisphere and partially in the Southern Hemisphere. Bears are found on the continents of North America, South America, Europe, and Asia. Common characteristics of modern bears include large bodies with stocky legs, long snouts, small rounded ears, shaggy hair, plantigrade paws with five nonretractile claws, and short tails.

Bear

The **deer** family, formally the family "Cervidae", are hoofed ruminant mammals. Male deer of all species (except the water deer) as well as female reindeer, grow and shed new antlers each year.

Deer

A diagram showing the high-level [data model of Neolace](/entry/x-002-graph-data-model).

Neolace Graph Data Model

Posts in this category are used to announce new features and other changes to the Neolace Platform.

Changelog

**reverse()** is for retrieving related entries, by *reversing* a relationship property. In a sense, it is the opposite of { entry("lookup-get") }. For example, `entry("justin-trudeau").get(prop=Father)` would give Pierre Trudeau; to get the reverse of that, you could use `entry("pierre-trudeau").reverse(prop=Father)`, which would give Justin Trudeau, his son. The "reverse" of the "Father" property is "Son" (in such cases, we don't ever need to define Son as a separate property; we just use Father and its reverse).

reverse()

We've just launched a major improvement to our graph visualization tools.

Improving Our Graph Visualization

Search for entries whose name or [key](/entry/term-key) contains the given text string.

basicSearch()

Lookup functions related to file contents.

Content File Related Functions

This guide explains how to create a new [Site](/entry/term-site) in Neolace.

How to create a new Neolace Site

ID Lookup Functions

Returns the descendants of the specified [entry](/entry/term-entry). Unlike { entry("lookup-andDescendants") }, the result will not include the original entry itself.

descendants()

The **orca** or **killer whale** (*Orcinus orca*) is a toothed whale belonging to the oceanic dolphin family, of which it is the largest member. It is recognizable by its black-and-white patterned body. A cosmopolitan species, orcas can be found in all of the world's oceans in a variety of marine environments, from Arctic and Antarctic regions to tropical seas.

Orca

Returns a list of the files attached to an entry (if the entry has the "Files" content feature enabled).

files()

This can be used to get the [entry type](/entry/term-entry-type) of an [entry](/entry/term-entry), or to get an [entry type](/entry/term-entry-type) from the [VNID](/entry/term-VNID) of that [entry type](/entry/term-entry-type).

entryType()

A lookup is a request for information from Neolace, similar to a **formula** in a spreadsheet program like Excel. A *lookup expression* like `this.ancestors().count()` is evaluated using the most up to date data, and it results in a *lookup value* like `5` which is then embedded in the entry or displayed to the user as requested.  See the [list of available lookup functions](//lookup?e=allEntries().filter(entryType%3DentryType("lookup-function"))) for examples.

Lookup

Returns the ancestors of the specified entry *and* the entry itself.

andAncestors()

A screenshot of the new graph visualization of selected PlantDB entries. This was generated using the lookup expression `[entry("s-pinus-ponderosa"), entry("s-thuja-plicata")].andAncestors().graph()`

Some PlantDB data graphed (latest Neolace version)

A Neolace **Realm** is an installation of Neolace, which hosts one or more [Sites](/entry/term-site). Neolace.com is an example of a Realm, and it hosts [sites](/entry/term-site) such as junction.neolace.com.

Realm

Given a list of entries or other values, this returns only the first one in the list.

first()

A screenshot of the graph visualization of selected TechNotes entries. This shows how you can now click on placeholders to load additional data into the graph as you explore it.

Streaming new entries into the graph

if() is used to return different results depending on whether or not some condition is true.

if()

The `allEntries()` lookup function returns all entries in the current site (that you have permission to see).

allEntries()

Every [Entry](/entry/term-entry) has a **key** string that uniquely identifies it. For example, the key of this { this } entry is **{ this.key }**. The key appears the in the URL of each entry - for example, the UR for this term ends with `/entry/{ this.key }`. You _can_ edit an entry to change its key, unlike its [VNID](/entry/term-VNID).

Relationship functions like ancestors(), descendants(), andRelated()

Relationship Functions

Get the image that the given entry contains (for entry types that have the image content feature enabled).

image()

Given a value, "annotate" it with additional information. This can influence how the value is sorted, or displayed in the frontend.

annotate()

Get a [property](/entry/term-property) given its [VNID](/entry/term-VNID). Note that this is for retrieving [properties](/entry/term-property) like "Total Area", not [property values](/entry/term-property-value) like "9,984,670 km^2^". To retrieve [property values](/entry/term-property-value), use { entry("lookup-get") }.

prop()

**Mammals** (from Latin *mamma*) are a group of vertebrate animals constituting the class Mammalia, characterized by the presence of mammary glands which in females produce milk for feeding (nursing) their young, a neocortex (a region of the brain), fur or hair, and three middle ear bones.

Mammal

Given a string like "2022-08-20", converts it into a Date value. This is the recommended way to represent calendar dates in Neolace. Note that these date objects are *calendar dates*, and do not include any time/timezone information.

date()

A screenshot of the older graph visualization of selected PlantDB entries. This was generated using the lookup expression `[entry("s-pinus-ponderosa"), entry("s-thuja-plicata")].andAncestors().graph()`

Some PlantDB data graphed (older Neolace version)

A **property value** is the value that a [property](/entry/term-property) has for a specific [entry](/entry/term-entry). For example, an entry about "Canada" would state that it has a "Total Area" of **9,984,670 km^2^** - in this case 9,984,670 km^2^ is the Property Value (for the "Total Area" [property](/entry/term-property)).

Property Value

The **Schema** defines the [Entry Types](/entry/term-entry-type) and [Properties](/entry/term-property) that can be used on each Neolace [Site](/entry/term-site).

Schema

Given a list of values, **map()** will transform it into a new list by changing each value in a certain way. For example, you can convert a list of entries into a list of entry names or a list of property values.

map()

**Oceanic dolphins** or **Delphinidae** are a widely distributed family of dolphins that live in the sea. Close to forty extant species are recognized. They include several big species whose common names contain "whale" rather than "dolphin", such as the killer whale and pilot whale. River dolphins are relatives of the Delphinoidea.

Oceanic dolphin

Blog Post

Deep Dive

Class

Family

Species

Entry Set

Explanation

How-to Guide

Image

Term

Specifies the class that this family belongs to.

Specifies the family that this species belongs to.

Junction is the Neolace resource hub, with documentation, blog posts, tutorials, and more.

On this page

graph()

Details

Arguments

Examples