Glossary

Aura

Aura: Neo4j's fully managed cloud service.
Aura Graph Analytics: The Aura service that runs graph algorithms in a separate session, with no plugin to install.
Aura Graph Analytics session: A managed, temporary compute environment that holds a projection and runs algorithms against it.
Aura instance: A single Neo4j database running in Aura.
AuraDB: The Aura product for transactional workloads.
AuraDS: The Aura product for data science workloads, with the Graph Data Science library installed.
implicit session: An Aura Graph Analytics session created together with its projection, in a single call.
standalone session: An Aura Graph Analytics session attached to no AuraDB instance, projecting instead from data you supply.

Cypher

aggregation: Grouping rows and computing a value over each group. In Cypher the grouping keys are whatever expressions in the same clause are not aggregated.
constraint: A rule the database enforces on every node or relationship with a given label or type, rejecting any write that breaks it.
Cypher: Neo4j's implementation of GQL, the ISO standard query language for graph databases. It is declarative: you describe the pattern to find, and the database decides how to find it.
index: A structure over a property. The database reads it to find nodes or relationships by property value, rather than scanning every one.
pattern: A graph structure written in Cypher, such as a node joined to another node by a relationship.
pattern matching: Finding every part of the graph that fits a given pattern.
unique constraint: A constraint that permits only one node or relationship with a given property value for its label or type.

Data modeling

data model: The labels, relationship types and properties chosen to represent a domain.
instance model: A data model drawn with real example data, showing particular nodes and relationships rather than their types.
intermediate node: A node introduced to act as an intermediate step between two or more other nodes, or to carry properties that a single relationship cannot.
refactoring: Changing the structure of a graph without changing what it represents, usually to make queries simpler, faster or more logical.

Drivers

driver: The client library an application uses to connect to Neo4j and run Cypher.
read transaction: A transaction that only reads, and so can be routed to any member of a cluster.
transaction: A unit of work that either succeeds in full or leaves no trace.
transaction function: A function the driver runs inside a transaction it manages, retrying it when a failure was transient.
write transaction: A transaction that changes data, and so is routed to the leader of a cluster.

GenAI and GraphRAG

embedding: Information represented as a numerical vector, positioned so that similar information sits close together.
generative AI: Models that produce new content rather than classifying or scoring content that already exists.
GraphRAG: Retrieval-augmented generation whose context comes from a knowledge graph, so the model can follow the relationships between facts.
hallucination: A false statement made confidently by a language model.
knowledge graph: A graph of entities and the relationships between them, used as a source of facts.
large language model: A model trained on text to predict the next token, and so to generate language.
prompt: The text given to a language model to produce a response.
retrieval-augmented generation: Fetching relevant context from an external data source as additional context to inform a language model's response.
retriever: A component that searches a data source and returns the information relevant to a query. Often used to provide context for a language model.
temperature: A number that sets how strongly a language model favours its highest-scoring next word. Low values keep it on the favourite, high values make it more likely to choose from words with lower scores.
text chunk: A piece of a larger document, small enough for a model to process and specific enough to be worth retrieving on its own.
vector: An ordered list of numbers. Distance between two vectors measures how alike the things they represent are.
vector index: A structure over a vector property. The database searches it to find the vectors nearest a given one, rather than comparing every vector stored.
vector search: Finding the records whose vectors lie closest to a query vector.

Graph Data Science

betweenness centrality: A score for each node equal to how often it lies on the shortest paths between other nodes.
centrality: How important a node is within a graph. Each centrality algorithm defines importance differently.
community detection: A family of algorithms that group nodes by how they connect. Each algorithm defines a community differently.
Cypher projection: A projection built from the rows a Cypher query returns, so it can hold nodes and relationships that are derived rather than stored.
degree centrality: A score for each node equal to its number of outgoing relationships.
Dijkstra's algorithm: An algorithm that finds the cheapest route between two nodes.
execution mode: How a GDS algorithm returns its results. One of stats, stream, mutate, write or estimate.
FastRP: A node embedding algorithm, short for Fast Random Projection. It builds each node's vector by combining random vectors drawn from the nodes around it.
graph catalog: The set of projections currently held in memory, each listed and dropped by name.
graph data science: Analysing data through the structure of its connections. Also the name of the Neo4j library that implements it.
Louvain algorithm: A community detection algorithm that repeatedly merges nodes into groups for as long as merging raises modularity.
modularity: A score for how much more densely connected the nodes within a group are than they would be by chance.
native projection: A projection built by naming node labels and relationship types directly, without a Cypher query.
node embedding: A list of numbers that stands in for a node's position in the graph, so that nodes in similar positions get similar lists.
node similarity: An algorithm that scores how alike two nodes are by comparing the neighbours they share.
PageRank: A centrality algorithm that scores a node by the number of nodes pointing at it and by how important those nodes are.
pathfinding: A family of algorithms that find routes through a graph. What counts as the best route differs by algorithm.
projection: An in-memory copy of part of your database that graph algorithms run against. You choose which nodes and relationships it holds.
relationship aggregation: Collapsing the parallel relationships between two nodes into one during projection, usually carrying their count or sum as its weight.
Union-Find: The algorithm underlying Weakly Connected Components. It holds each node in a set, and merges two sets whenever a relationship joins them.
weakly connected components: Groups of nodes in which every node is reachable from every other, once relationship direction is ignored. The GDS algorithm that finds them takes the same name.
Yen's algorithm: An algorithm that finds the k cheapest routes between two nodes, rather than only the cheapest.

Graphs

bipartite graph: A graph with two kinds of node, where every relationship joins one kind to the other and never two of the same kind.
directed relationship: A relationship that runs one way, from its start node to its end node. Every relationship Neo4j stores is directed.
graph: A set of vertices, with edges joining pairs of them. Neo4j calls vertices nodes and edges relationships.
heterogeneous graph: A graph that holds more than one node label or more than one relationship type.
label: A tag on a node that groups it with other nodes of the same kind. A node can carry more than one.
monopartite graph: A graph in which every node is the same kind of thing, so relationships connect like to like.
multipartite graph: A graph with three or more kinds of node, where relationships only ever join nodes of different kinds.
node: A vertex in a graph. In a property graph it can carry labels and properties.
path: A sequence of nodes joined by relationships.
property: A named value stored on a node or a relationship.
property graph: The data model Neo4j implements, in which nodes and relationships both carry properties as well as labels and types.
relationship: A named, directed connection between two nodes. Every relationship has a type, a start node and an end node.
traversal: Following relationships from one node to the next to reach other parts of a graph.
undirected relationship: A relationship with no direction. Neo4j GDS represents them as parallel relationships in opposite directions.
weighted graph: A graph whose relationships carry a numeric property that algorithms and queries can read as a cost or a strength.

Importing

Data Importer: The Neo4j tool for loading CSV files into a graph by mapping their columns onto nodes and relationships.
LOAD CSV: The Cypher clause that reads a CSV file row by row, so those rows can be written into the graph.