Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
neo4j-contrib avatar

Neo4j Snowflake Graph Analytics Skill

neo4j-contrib/neo4j-skills

  • 312 installs
  • 101 repo stars
  • Updated August 3, 2026
  • neo4j-contrib/neo4j-skills

Neo4j Snowflake Graph Analytics Skill is an agent skill that helps you install Neo4j Graph Analytics on Snowflake and write SQL to run graph algorithms on warehouse tables.

About

Neo4j Snowflake Graph Analytics Skill teaches agents to use Neo4j Graph Analytics for Snowflake—a Native Application that exposes graph algorithms as SQL procedures on warehouse tables. Solo builders and small data teams install it when they need PageRank, Louvain, Dijkstra, node similarity, and related workloads without exporting data to a separate graph cluster. The skill walks through marketplace setup, privilege grants, compute pool sizing, projection definitions, and the repeatable project-compute-write workflow. It also helps pick algorithms for fraud detection, recommendations, and entity resolution, chain multi-step jobs, and fix projection or permission failures. Expect intermediate Snowflake and SQL fluency; outputs are runnable SQL and configuration patterns aligned with Neo4j’s current Snowflake documentation.

  • Covers Snowflake Marketplace install and required roles or privileges
  • Documents the project → compute → write pattern for every algorithm job
  • SQL syntax and projection config for node tables, relationships, and orientation
  • Algorithm catalog spans community detection, centrality, pathfinding, similarity, and embeddings
  • Guidance on chaining algorithms, views for column mismatches, and common error troubleshooting

Neo4j Snowflake Graph Analytics Skill by the numbers

  • 312 all-time installs (skills.sh)
  • +25 installs in the week ending Aug 4, 2026 (Skillselion tracking)
  • Ranked #174 of 911 Databases skills by installs in the Skillselion catalog
  • Security screen: LOW risk (skills.sh audit)
  • Data as of Aug 4, 2026 (Skillselion catalog sync)
npx skills add https://github.com/neo4j-contrib/neo4j-skills --skill neo4j-snowflake-graph-analytics-skill

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs312
repo stars★ 101
Security audit3 / 3 scanners passed
Last updatedAugust 3, 2026
Repositoryneo4j-contrib/neo4j-skills ↗

What it does

Run Neo4j graph algorithms inside Snowflake SQL for fraud, recommendations, and entity resolution without leaving the warehouse.

Who is it for?

Best when you're adding fraud, recommendation, or entity-resolution graph jobs directly in Snowflake with marketplace-native Neo4j Graph Analytics.

Skip if: Skip if you only need casual BI aggregates in SQL with no graph structure, or those without Snowflake Native Apps and compute pools.

When should I use this skill?

Writing SQL for graph algorithms on Snowflake, first-time Neo4j Graph Analytics setup, picking algorithms for business problems, sizing compute pools, or fixing privilege and projection errors.

What you get

You get correct install steps, privilege setup, projection configs, and SQL for chosen algorithms following the project → compute → write pattern.

  • Marketplace install and privilege checklist
  • Projection and algorithm SQL using project → compute → write
  • Chained multi-algorithm job patterns and troubleshooting notes

By the numbers

  • Five algorithm families: community detection, centrality, pathfinding, similarity, and node embeddings
  • Standard job flow: project → compute → write
  • Covers WCC, Louvain, Leiden, PageRank, Dijkstra, node similarity, KNN, and related variants

Files

SKILL.mdMarkdownGitHub ↗

Snowflake Native App — graph algorithm power inside Snowflake. Data stays in Snowflake; project into a graph, run algorithms via SQL CALL, results written back to Snowflake tables.

Docs: https://neo4j.com/docs/snowflake-graph-analytics/current/

---

When to Use

  • Running graph algorithms / GDS in Snowflake
  • Data already lives in Snowflake tables
  • On-demand / pipeline workloads — ephemeral sessions, pay per session-minute
  • Full isolation from the live database during analytics

When NOT to Use

  • Aura Pro with embedded GDS plugin → neo4j-gds-skill
  • Aura Graph Analytics → neo4j-aura-graph-analytics-skill
  • Self-managed Neo4j with embedded GDS plugin → neo4j-gds-skill
  • Writing Cypher queries → neo4j-cypher-skill

---

The End-to-End Flow

This is the flow that works. Don't jump straight to a CALL — most failures come from skipping the data-preparation step.

1. Explore the source data — inspect table DDLs to learn columns and types. 2. Prepare projection views — create node/relationship views that expose the required key columns and cast every property to a supported type (see the strict rules below). This is the step that matters most. 3. Project → Compute → Write — run the algorithm with a single CALL, assembling the project, compute, and write config. 4. Inspect & look up names — join numeric results back to the source table to get human-readable labels.

---

Step 1 — Explore the Source Data

Look at the table definitions before designing the graph:

SELECT GET_DDL('TABLE', 'MY_DATABASE.MY_SCHEMA.MY_TABLE');
-- or inspect columns/types:
SELECT COLUMN_NAME, DATA_TYPE
FROM MY_DATABASE.INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_SCHEMA = 'MY_SCHEMA' AND TABLE_NAME = 'MY_TABLE';

Decide which tables are nodes and which represent relationships (edges) between them.

---

Step 2 — Prepare Projection Views (the important part)

The graph engine is strict about column names and types. Snowflake views inherit the source column type by default, so you MUST add explicit CASTs — never SELECT col without one for a property column.

Create views that reshape your tables into the node/relationship format:

CREATE OR REPLACE VIEW MY_DATABASE.MY_SCHEMA.MY_NODES_VW AS
SELECT ... FROM MY_DATABASE.MY_SCHEMA.MY_TABLE;

Node views

  • Key column: expose the primary key as NODEID. It must be BIGINT or STRING. Always alias and cast explicitly:

SOURCE_COL::BIGINT AS NODEID or SOURCE_COL::STRING AS NODEID.

  • Allowed node property types (exactly): BIGINT, DOUBLE, ARRAY, VECTOR(FLOAT, n). Anything else must be cast to one of these or dropped.
  • Composite keys: concatenate parts with '++'.
  • Naming: <table>_NODES_VW.

Source-type → view-type casting rules

Apply these when projecting columns from your tables (keep the original column name unless renaming):

Source typeAction
Whole-number numerics (INT, INTEGER, BIGINT, SMALLINT, TINYINT, BYTEINT, NUMBER(p,0))CAST(col AS BIGINT) AS col
Fractional numerics (FLOAT, DOUBLE, REAL, DECIMAL(p,s>0), NUMBER(p,s>0))CAST(col AS DOUBLE) AS col
ARRAY of numberskeep as ARRAY (except GraphSAGE — see below). Not allowed on relationship views.
VECTOR(FLOAT, n)keep as-is. Not allowed on relationship views.
BOOLEANdrop by default. Opt-in only: IFF(col, 1, 0)::BIGINT AS col
DATE, TIME, TIMESTAMP*drop by default. Opt-in only: DATE_PART('EPOCH_SECOND', col)::BIGINT AS col (tell the user the unit)
VARCHAR, CHAR, TEXT, STRINGdrop — can't be a graph property. To read results by name, join output back to the source table on the key (see Step 4)
VARIANT, OBJECT, GEOGRAPHY, GEOMETRY, BINARYdrop — not supported as graph properties

Lowest-common-denominator policy: by default include only safe columns (numeric → BIGINT/DOUBLE, ARRAY, VECTOR). Booleans and time-like columns require explicit opt-in. When you drop columns, briefly tell the user which and why, so they can ask for them back.

Relationship views

  • Key columns: expose SOURCENODEID and TARGETNODEID, cast with the same rules as NODEID

(SOURCE_COL::BIGINT AS SOURCENODEID, etc.). Every value must match an existing NODEID in a node view.

  • Allowed relationship property types (narrower): BIGINT, DOUBLE, INT only. No `ARRAY`, no `VECTOR`. (The docs describe relationship properties as FLOAT; the engine accepts these whole/fractional numeric casts and treats them as weights — keep them numeric.)
  • Naming: <table>_RELATIONSHIPS_VW.

Example node + relationship views:

CREATE OR REPLACE VIEW MY_DATABASE.MY_SCHEMA.USER_NODES_VW AS
SELECT user_id::BIGINT AS NODEID,
       CAST(age AS BIGINT)        AS age,
       CAST(balance AS DOUBLE)    AS balance
FROM MY_DATABASE.MY_SCHEMA.USERS;

CREATE OR REPLACE VIEW MY_DATABASE.MY_SCHEMA.TRANSFERS_RELATIONSHIPS_VW AS
SELECT from_user::BIGINT AS SOURCENODEID,
       to_user::BIGINT   AS TARGETNODEID,
       CAST(amount AS DOUBLE) AS amount
FROM MY_DATABASE.MY_SCHEMA.TRANSFERS;
The required logical column names are nodeId / sourceNodeId / targetNodeId — Snowflake folds unquoted identifiers to uppercase, so NODEID etc. match. Casting explicitly is what matters.

---

Step 3 — Project → Compute → Write

Every run is a single CALL whose first argument is the compute pool and second is a JSON config with three parts. Note JSON uses single quotes in Snowflake SQL.

App name: Neo4j_Graph_Analytics is only the default installation name. If the app was installed under a different name, replace it everywhere — in the procedure call (<APP>.graph.<algo>), the USE DATABASE <APP> statement, and the privilege grants below. Check with SHOW APPLICATIONS;.
USE ROLE MY_CONSUMER_ROLE;

CALL Neo4j_Graph_Analytics.graph.wcc('CPU_X64_XS', {
    'defaultTablePrefix': 'MY_DATABASE.MY_SCHEMA',
    'project': {
        'nodeTables': ['USER_NODES_VW'],
        'relationshipTables': {
            'TRANSFERS_RELATIONSHIPS_VW': {
                'sourceTable': 'USER_NODES_VW',
                'targetTable': 'USER_NODES_VW',
                'orientation': 'NATURAL'
            }
        }
    },
    'compute': { 'consecutiveIds': true },
    'write': [{
        'nodeLabel': 'USER_NODES_VW',
        'outputTable': 'result_wcc_user_communities'
    }]
});

SELECT * FROM MY_DATABASE.MY_SCHEMA.result_wcc_user_communities;

Config parts

  • `defaultTablePrefix` — set to the database + schema where your views and output tables live (DB.SCHEMA); lets you reference them by short name.
  • `project` — nodeTables (array; each maps to a label) and relationshipTables (map; each key maps to a type, with sourceTable/targetTable/orientation).
  • `compute` — algorithm parameters. Omit any parameter whose value would be null.
  • `write` — a list of write targets. nodeLabel (or sourceLabel/targetLabel) is the table/view name of the nodes being written. For relationship results use relationshipType.

Orientation

Set orientation per relationship table in relationshipTables:

  • NATURAL (default) — directed, source → target (as stored in the table).
  • UNDIRECTED — treated as bidirectional (each relationship is included in both directions).
  • REVERSE — direction flipped, target → source.

Choose based on the algorithm:

  • `UNDIRECTED` — community detection that treats edges symmetrically: WCC, Louvain, Leiden, Label Propagation. Triangle Count requires `UNDIRECTED`.
  • `NATURAL` — directed-flow and ranking: PageRank, Article Rank, Dijkstra and the other pathfinding algorithms, Max Flow. Node Similarity expects a bipartite graph (two disjoint node sets) projected NATURAL; use REVERSE to compare the other node set instead.
  • KNN ignores relationships entirely — similarity comes from node properties, so orientation has no effect on it (and K-Means likewise uses only node properties).

Compute pools (first CALL argument)

PoolUse
CPU_X64_XSDefault — dev / small graphs
CPU_X64_S/M/LProgressively larger
HIGHMEM_X64_S/M/LLarge graphs, lower CPU need
GPU_NV_XS, GPU_NV_S, GPU_GCP_NV_L4_1_24GGraphSAGE / GPU work (availability varies by region)

Prefer CPU_X64_XS unless the user asks otherwise or GraphSAGE makes a GPU pool appropriate. See Estimating Jobs.

Result table naming

Name output tables result_<algotag>_<short_description>, underscores only, no spaces/special chars (e.g. result_louvain_customer_segments). When writing multiple node labels, use a distinct table per label.

---

Step 4 — Inspect & Look Up Names

What the algorithm produces depends on its type — check the algorithm's write config:

  • Node-property results (centrality, community detection, k-means, embeddings, FastPath) — a table keyed by NODEID.
  • Relationship results (Node Similarity, KNN, Dijkstra & other pathfinding, Max Flow) — a table keyed by SOURCENODEID / TARGETNODEID. BFS and other heterogeneous writes also add SOURCELABEL / TARGETLABEL, with the node IDs stored as strings.
  • A model (GraphSAGE training) — no output table; it writes to the model catalog. Use the model later for prediction, which then produces a node-property table.

VARCHAR labels were dropped during projection, so join the result back to the source table on the key column(s) to get readable names. For node-property results, join on NODEID:

SELECT u.name, u.country, r.score
FROM MY_DATABASE.MY_SCHEMA.result_page_rank_influence r
JOIN MY_DATABASE.MY_SCHEMA.USERS u
  ON r.NODEID = u.user_id
ORDER BY r.score DESC
LIMIT 10;

For relationship results, join the source table twice — once on SOURCENODEID and once on TARGETNODEID.

---

Available Algorithms

Procedure = Neo4j_Graph_Analytics.graph.<name>. Names below are exact.

For complete algorithm compute/write parameter reference, see references/algorithms.md.

Community Detection

AlgorithmProcedureUse case
Weakly Connected ComponentswccFind disconnected subgraphs
LouvainlouvainCommunity detection (modularity)
LeidenleidenCommunity detection, more stable than Louvain
Label Propagationlabel_propagationFast community detection by label spreading
K-MeanskmeansCluster nodes by node properties
Triangle Counttriangle_countLocal clustering / dense subgraphs

Centrality

AlgorithmProcedureUse case
PageRankpage_rankRank nodes by influence
Article Rankarticle_rankPageRank variant, discounts high-degree neighbours
BetweennessbetweennessFind bridge nodes
DegreedegreeCount direct connections

Pathfinding

AlgorithmProcedureUse case
Dijkstra Source-TargetdijkstraShortest path(s) from source to target(s) or pairs
Dijkstra Single-Sourcedijkstra_single_sourceShortest paths from one node to all others
Delta-Stepping SSSPdelta_steppingParallel single-source shortest paths
Breadth First SearchbfsBFS traversal from a source
Yen's K-Shortest PathsyensTop-K shortest loopless paths
Max Flowmax_flowMaximum flow with capacities
Min-Cost Max Flowmax_flow_min_costMax flow minimising total cost
FastPathfastpathFast approximate shortest paths

Similarity

AlgorithmProcedureUse case
Node Similaritynode_similaritySimilar nodes by shared neighbours
Filtered Node Similaritynode_similarity_filteredNode similarity with source/target filters
KNNknnK most similar nodes
Filtered KNNknn_filteredKNN with source/target filters

Node Embeddings

AlgorithmProcedureUse case
FastRPfast_rpFast node embeddings
Node2Vecnode2vecRandom-walk node embeddings
HashGNNhashgnnGNN-inspired embeddings without training

GraphSAGE (Graph ML)

AlgorithmProcedureUse case
Node Classification — traings_nc_trainTrain supervised node-label model
Node Classification — predictgs_nc_predictPredict labels with a trained model
Unsupervised embeddings — traings_unsup_trainTrain unsupervised embedding model
Unsupervised embeddings — predictgs_unsup_predictInfer embeddings with a trained model

Model catalog (GraphSAGE)

show_models, model_exists, drop_model.

---

Algorithm-Specific Notes

GraphSAGE

  • Projected node tables used by GraphSAGE must not contain ARRAY property columns — use VECTOR(FLOAT, n) for multi-valued numeric features. (ARRAY is fine for non-GraphSAGE algorithms.)
  • Feature columns must be non-NULL and finite — filter, impute, or exclude nullable feature columns in the view. For gs_nc_train, the targetProperty is a label (not a feature) and may be NULL.
  • Before running, list the node properties GraphSAGE will use per node table: all non-NODEID columns; for gs_nc_train exclude the targetProperty.
  • Training (gs_nc_train, gs_unsup_train) can be slow and may use a GPU pool (GPU_NV_S). Show the exact CALL and get explicit confirmation before running training.

Dijkstra Source-Target (dijkstra)

Provide one of:

  • single pair: sourceNode + sourceNodeTable, targetNode + targetNodeTable;
  • one source, many targets: sourceNode + sourceNodeTable, targetNodes (list) + targetNodesTable;
  • many pairs: sourceTargetNodePairsTable (table with SOURCENODEID/TARGETNODEID columns) + sourceNodeTable + targetNodeTable.

General

  • Never use NODEID itself as an algorithm property.
  • Omit any config parameter whose value is null.

---

Installation

1. Install Neo4j Graph Analytics from the Snowflake Marketplace (default app name Neo4j_Graph_Analytics). 2. Enable Event sharing when prompted. 3. Data Products → Apps → Neo4j Graph Analytics → Privileges → Grant: grant CREATE COMPUTE POOL and CREATE WAREHOUSE, then click Activate.

---

Privilege Setup (run once per database/schema)

USE ROLE ACCOUNTADMIN;

-- Consumer role for app users
CREATE ROLE IF NOT EXISTS MY_CONSUMER_ROLE;
GRANT APPLICATION ROLE Neo4j_Graph_Analytics.app_user TO ROLE MY_CONSUMER_ROLE;
SET MY_USER = (SELECT CURRENT_USER());
GRANT ROLE MY_CONSUMER_ROLE TO USER IDENTIFIER($MY_USER);

-- Database role granting the app access to your data
USE DATABASE MY_DATABASE;
CREATE DATABASE ROLE IF NOT EXISTS MY_DB_ROLE;
GRANT USAGE ON DATABASE MY_DATABASE TO DATABASE ROLE MY_DB_ROLE;
GRANT USAGE ON SCHEMA MY_DATABASE.MY_SCHEMA TO DATABASE ROLE MY_DB_ROLE;
GRANT SELECT ON ALL TABLES  IN SCHEMA MY_DATABASE.MY_SCHEMA TO DATABASE ROLE MY_DB_ROLE;
GRANT SELECT ON ALL VIEWS   IN SCHEMA MY_DATABASE.MY_SCHEMA TO DATABASE ROLE MY_DB_ROLE;
-- FUTURE grants let the app read tables/views it creates (needed for chaining)
GRANT SELECT ON FUTURE TABLES IN SCHEMA MY_DATABASE.MY_SCHEMA TO DATABASE ROLE MY_DB_ROLE;
GRANT SELECT ON FUTURE VIEWS  IN SCHEMA MY_DATABASE.MY_SCHEMA TO DATABASE ROLE MY_DB_ROLE;
GRANT CREATE TABLE ON SCHEMA MY_DATABASE.MY_SCHEMA TO DATABASE ROLE MY_DB_ROLE;
GRANT DATABASE ROLE MY_DB_ROLE TO APPLICATION Neo4j_Graph_Analytics;

-- Let the consumer role read output tables
GRANT USAGE ON DATABASE MY_DATABASE TO ROLE MY_CONSUMER_ROLE;
GRANT USAGE ON SCHEMA MY_DATABASE.MY_SCHEMA TO ROLE MY_CONSUMER_ROLE;
GRANT SELECT ON FUTURE TABLES IN SCHEMA MY_DATABASE.MY_SCHEMA TO ROLE MY_CONSUMER_ROLE;

USE ROLE MY_CONSUMER_ROLE;   -- run algorithms as the consumer role
Replace MY_DATABASE, MY_SCHEMA, MY_CONSUMER_ROLE, MY_DB_ROLE with your names throughout.

---

Common Patterns

Chaining algorithms

Because results write to tables (and the FUTURE TABLES grant lets the app read what it creates), feed one algorithm's output into the next:

-- 1. Embeddings
CALL Neo4j_Graph_Analytics.graph.fast_rp('CPU_X64_XS', { ... });
-- 2. KNN over the embedding output table (projected as a node view)
CALL Neo4j_Graph_Analytics.graph.knn('CPU_X64_XS', { ... });

Convert categorical data to numeric

The graph engine can't use VARCHAR as a property. Map categories to numbers in the view (e.g. CASE / a lookup join). To read results by their original label, join the output table back to the source table on the key.

---

Troubleshooting

ProblemSolution
Insufficient privilegesApp needs SELECT on your tables/views and CREATE TABLE on the schema (see Privilege Setup)
Column nodeId not foundView is missing/mis-cast the key — expose NODEID (and SOURCENODEID/TARGETNODEID) with explicit casts
Type / projection error on a propertyA property column wasn't cast to a supported type — apply the casting rules; relationship props must be BIGINT/DOUBLE/INT
GraphSAGE fails on featuresRemove ARRAY feature columns (use VECTOR), and ensure features are non-NULL/finite
Compute pool not availablePool may still be starting; wait a minute and retry
Algorithm returns no resultsCheck node/relationship views aren't empty and that every SOURCENODEID/TARGETNODEID matches a NODEID

Full guide: https://neo4j.com/docs/snowflake-graph-analytics/current/troubleshooting/

---

Further Reading

---

Checklist

  • [ ] App installed; privileges granted on the database/schema
  • [ ] Views expose NODEID / SOURCENODEID / TARGETNODEID, every property explicitly cast
  • [ ] orientation matches the algorithm
  • [ ] Single CALL ran without error; output table populated
  • [ ] Results joined back to source table for readable labels

Related skills

open.feishu.cnLark BaseLet their coding agents read from, write to, and query structured data stored in Lark Base (Feishu) spreadsheets and databases.493kmicrosoftAzure KustoRun fast KQL queries against Azure Data Explorer for log analytics, telemetry, and time-series data.484k1.3klarksuiteLark SheetsCreate, read, update, and export spreadsheets inside Lark (Feishu) directly from their AI coding agent.389k15.9ksupabaseSupabase Postgres Best PracticesAutomatically apply Supabase Postgres performance rules during query writing, schema design, and database optimization.313k2.4kfirebaseFirebase Data ConnectGenerate complete, production-ready Firebase Data Connect GraphQL schemas and queries for complex relational data models.112k392firebaseFirebase FirestoreAdd Cloud Firestore read/write capabilities to an Android Kotlin app using the official Firebase SDK.77k392

How it compares

Use instead of hand-rolled NetworkX or external Neo4j ETL when the source of truth already lives in Snowflake tables.

FAQ

Who is neo4j-snowflake-graph-analytics-skill for?

Data-minded developers and teams shipping analytics on Snowflake who want graph algorithms via SQL procedures rather than a separate graph ops stack.

When should I use neo4j-snowflake-graph-analytics-skill?

During Build integrations when first enabling the Native App, writing algorithm SQL, sizing compute pools, or debugging projection and privilege errors on Snowflake graph jobs.

Is neo4j-snowflake-graph-analytics-skill safe to install?

Treat it like any third-party agent skill: review the Security Audits panel on this Prism page and restrict Snowflake roles and secrets before letting an agent run marketplace installs or production SQL.

Databasesdatabasesanalyticspipelines
Browse by category
AI & AgentsFrontend & DesignBackend & DataDev ToolsAutomationTesting & ReviewSecurityMonitoring & CloudDocs & Planning
Design & frontend
Design systemsAnimation & motionAccessibility (a11y)CSS & TailwindUI designUXDesign to codeshadcn/uiLanding pagesBest design skills
Most searched skills
find-skillscavemanfrontend-designbrainstormingsystematic-debuggingstop-slopemil-design-engui-ux-pro-maxkarpathy-guidelinesweb-design-guidelinesreact-best-practicesgrill-meimprovemicrosoft-foundryagent-browser
Browse all listings
All agent skillsAll MCP serversAll marketplacesAll plugins

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.