Whole-Graph Projections in Neo4j Bloom: Visual Graph Analytics at Scale

Teaser: Neo4j Bloom now runs GDS algorithms — PageRank, Louvain, Betweenness Centrality, Shortest Path, FastRP — directly from the visual interface, projecting results as interactive graph layers. No Cypher, no Python, no context switching. This article covers the 18 available algorithms, the Bloom projection workflow, and a complete fraud ring detection example from exploration to export.

Introduction

In July 2026, Neo4j launched Whole-Graph Projections in Bloom — a feature that lets analysts run Graph Data Science (GDS) algorithms directly from the visual query interface and explore the results as interactive graph projections.

Previously, running GDS algorithms required switching between Neo4j Browser (for Cypher), the GDS Python client (for algorithm configuration), and potentially a separate visualisation tool (for results). Whole-Graph Projections collapses this workflow into a single Bloom session: select nodes and relationships, choose an algorithm, configure parameters through a visual form, and immediately see the results rendered as a new graph projection.

For teams using Bloom as their primary graph exploration tool, this bridges the gap between visual ad-hoc querying and algorithmic graph analytics.

The Gap: Visual Exploration ↔ Analytical Computation

Bloom has long excelled at interactive graph exploration — searching nodes, expanding relationships, styling subgraphs. GDS, meanwhile, provides 50+ graph algorithms (centrality, community detection, pathfinding, node embedding) but has historically required programmatic access through Cypher CALL procedures or the Python client.

The workflow friction was significant:

Before Whole-Graph Projections:

  1. Bloom: Explore → find interesting subgraph
  2. Switch to Browser: Run CALL gds.graph.project(...)
  3. Switch to Python/Browser: CALL gds.pageRank.stream(...)
  4. Export results → re-import into Bloom
  5. Style nodes by PageRank score → analyse

After Whole-Graph Projections:

  1. Bloom: Explore → find interesting subgraph
  2. Bloom: Right-click → "Run Graph Algorithm"
  3. Bloom: Configure PageRank → "Project Results"
  4. Analyse the projected graph in-place

Whole-Graph Projections eliminates steps 2–4, keeping the analyst inside Bloom for the entire workflow.

How It Works

Whole-Graph Projections extends Bloom's rendering engine to support GDS algorithm results as first-class visual projections. The flow is:

Step 1: Define the Graph

Start with any Bloom query — a pattern match, a neighbourhood expansion, or the entire graph. Bloom's existing search and expansion tools work unchanged.

Step 2: Select the Algorithm

The core workflow follows a simple loop:

graph LR
    A[Explore in Bloom] --> B[Select subgraph]
    B --> C[Choose algorithm]
    C --> D[Configure parameters]
    D --> E[Run & Project]
    E --> F[Interact with projection]
    F -->|Refine| B
    F -->|Export| G[Subgraph / CSV]

    classDef action fill:#4C78A8,stroke:#2c4e6e,color:#fff
    classDef result fill:#54A24B,stroke:#3a7a35,color:#fff
    class A,B,C,D action
    class E,F result

Step 3: Configure Parameters

Right-click the canvas and choose Run Graph Algorithm. Bloom presents a dialog with available GDS algorithms:

┌──────────────────────────────────────────┐
│  Run Graph Algorithm                     │
│                                          │
│  Algorithm: ┌─────────────────────────┐  │
│             │ PageRank                │  │
│             │ Betweenness Centrality  │  │
│             │ Louvain (Community)     │  │
│             │ Label Propagation       │  │
│             │ Shortest Path           │  │
│             │ Node Similarity         │  │
│             │ FastRP                  │  │
│             │ GraphSAGE               │  │
│             └─────────────────────────┘  │
│                                          │
│  Run on:  ◎ Current selection             │
│           ○ All visible nodes             │
│           ○ Entire graph                  │
│                                          │
│  [Mutate]  [Stream]  [Project Results]   │
└──────────────────────────────────────────┘

Step 3: Configure Parameters

Each algorithm exposes its GDS configuration parameters through a visual form. For Louvain community detection:

┌──────────────────────────────────────────┐
│  Louvain Configuration                   │
│                                          │
│  Relationship weight:  ○ None            │
│                       ○ Use property:    │
│                       ┌──────────────┐   │
│                       │ transactionAmt│   │
│                       └──────────────┘   │
│  Max levels:          [3]                │
│  Max iterations:      [50]               │
│  Tolerance:           [0.0001]            │
│  Include intermediate: ☐                 │
│                                          │
│  ┌──────────────────────────────────────┐│
│  │  Run & Project                      ││
│  └──────────────────────────────────────┘│
└──────────────────────────────────────────┘

Step 4: Explore the Projected Graph

When the algorithm completes, Bloom creates a projected graph layer — a new visualisation that overlays the algorithm results onto the existing graph. Nodes are coloured and sized by algorithm scores:

• PageRank: Node size ∝ PageRank score, colour intensity ∝ rank percentile
• Louvain: Nodes coloured by community ID, clusters visually distinct
• Betweenness: Node size ∝ betweenness score, high-betweenness nodes highlighted
• Shortest Path: Path edges highlighted, waypoint nodes annotated

The projection is interactive — you can expand nodes from the projected graph, run additional queries, or apply the results as a node property filter.

The Algorithms Available

Whole-Graph Projections supports 18 GDS algorithms at launch, grouped into four categories:

Centrality

Algorithm	What It Measures	Bloom Visualisation
PageRank	Node importance via inbound links	Node size, colour ramp
Betweenness Centrality	Node bridge/connector value	Highlighted markers
Closeness Centrality	Node reachability	Radial gradient
Degree Centrality	Connection count	Node size

Community Detection

Algorithm	What It Finds	Bloom Visualisation
Louvain	Hierarchical communities	Colour-coded clusters
Label Propagation	Overlapping communities	Colour-coded, blended
Leiden	Improved Louvain	Colour-coded clusters
Weakly Connected Components	Disconnected subgraphs	Region highlighting
Triangle Count	Local clustering	Node badge

Pathfinding

Algorithm	What It Computes	Bloom Visualisation
Shortest Path (A*)	Optimal path between nodes	Path highlighting
All Pairs Shortest Path	Distance matrix	Heat map overlay
Minimum Spanning Tree	Minimal connection tree	Tree layout
BFS/DFS	Traversal order	Step-by-step animation

Node Embedding

Algorithm	What It Produces	Bloom Visualisation
FastRP	Dense node vectors	Similarity-based layout
GraphSAGE	Inductive embeddings	Subgraph similarity
Node2Vec	Random-walk embeddings	2D projection

Practical Workflow: Fraud Ring Detection

Here's a complete workflow using Whole-Graph Projections to detect potential fraud rings:

1. Load the transaction graph — A Bloom search for MATCH (p:Person)-[:TRANSFERRED]->(a:Account) returns the core transaction network.

2. Run Louvain community detection — Right-click → Run Graph Algorithm → Louvain → Run & Project. Bloom colours nodes by community.

3. Identify suspicious clusters — One community shows 15 accounts all transferring to a single account. The cluster is visually distinct from the rest of the graph.

4. Run PageRank on the suspicious community — Select the cluster, right-click → PageRank. Several accounts have anomalously high PageRank scores relative to their transaction volume — a known fraud indicator.

5. Compute shortest paths — Select two suspected fraudulent accounts → Shortest Path → identify intermediary accounts that connect them.

6. Export the projection — The full projected graph (with algorithm scores as node properties) can be exported as a subgraph definition for downstream systems.

Performance

Whole-Graph Projections runs algorithms on the GDS execution engine, not in the browser. Only the projected results are sent to Bloom:

Graph Size	Louvain Execution	Projection Transfer	Bloom Render
10K nodes, 50K edges	~200ms	~50ms	~100ms
100K nodes, 500K edges	~1.5s	~200ms	~400ms
1M nodes, 5M edges	~12s	~1.5s	~3s

The "Run on: Entire graph" option supports up to 10 million nodes in the current preview, with larger graphs supported through sampling or subgraph selection.

Limitations

Limitation	Details
Node-aligned algorithms only	Relationship-level algorithms (Link Prediction, Common Neighbours) projected as node properties; edge visual projections in development.
Single algorithm per projection	Multi-algorithm pipelines require sequential projections.
Preview storage	Projected graphs are ephemeral — visible only in the current Bloom session. Use MATERIALIZE to persist.
Graph size limit	10M nodes for "Entire graph" mode. Subgraph selection recommended for larger graphs.

Comparison

Feature	Whole-Graph Projections	Neo4j Browser + GDS	Python GDS Client	Gephi
Visual algorithm config	✅ Visual forms	❌ Cypher only	❌ Code only	⚠️ GUI
In-place visualisation	✅ Native Bloom	❌ Separate export	❌ Separate export	✅ Native
Interactive expansion	✅ Post-projection	❌	❌	⚠️ Limited
Result styling	✅ Automatic	❌ Manual	❌ Manual	✅ Automatic
Multi-algorithm workflow	⚠️ Sequential	✅ Scriptable	✅ Scriptable	⚠️ Sequential
Export	✅ Subgraph, CSV	✅ CSV, JSON	✅ All formats	✅ All formats

Conclusion

Whole-Graph Projections in Bloom represents a maturing of the graph analytics toolchain. By bringing GDS algorithms into the visual exploration environment, Neo4j closes the loop between "I see something interesting" and "let me analyse it algorithmically" — without requiring the analyst to leave Bloom or write a single line of Cypher or Python.

For graph data scientists, the feature reduces iteration time on algorithm selection and parameter tuning. For business analysts who work primarily in Bloom, it unlocks analytical capabilities that previously required developer intervention. The result is a tighter feedback loop between human pattern recognition and computational graph analysis.

Whole-Graph Projections is available on Neo4j AuraDB Enterprise and Neo4j 5.26+ as part of the Bloom 2026.07 release. Enable it from the Bloom settings panel under Experimental Features.