Node Similarity, KNN, Jaccard/Overlap/Cosine Concepts, and Candidate Generation

Learning outcomes

1. AtlasMart problem: “similar customer” can mean shared neighbors or similar features

AtlasMart recommendation engineers ask for similar customers. In graph analytics, that phrase can mean two different mechanisms. Node Similarity compares overlap in outgoing neighborhoods in a bipartite graph. KNN compares configured node properties such as numeric vectors and uses approximate neighbor search machinery. They can both produce candidate pairs, but their evidence is different.

2. Structural versus property-based similarity

Using the same word “cosine” does not make two experiments equivalent. In Node Similarity, cosine may be applied to weighted neighbor vectors; in KNN, cosine can compare a list-of-float property such as a deterministic feature vector.

3. Build a customer-view bipartite graph with a manual baseline

UNWIND [
  ['CH24-SIM-C1','Ada'], ['CH24-SIM-C2','Ben'], ['CH24-SIM-C3','Cy']
] AS row
CREATE (:Customer:CH24SimilarityCustomer {customerId:row[0], name:row[1], chapter24:true});

UNWIND range(1,4) AS i
CREATE (:Product:CH24SimilarityProduct {
  productId:'CH24-SIM-P' + toString(i),
  name:'Similarity Product ' + toString(i),
  featureVec: CASE i
    WHEN 1 THEN [1.0,0.0,0.1]
    WHEN 2 THEN [0.9,0.1,0.1]
    WHEN 3 THEN [0.1,0.9,0.2]
    ELSE [0.0,1.0,0.3] END,
  chapter24:true
});

MATCH (c1:Customer {customerId:'CH24-SIM-C1'}),
      (c2:Customer {customerId:'CH24-SIM-C2'}),
      (c3:Customer {customerId:'CH24-SIM-C3'}),
      (p1:Product {productId:'CH24-SIM-P1'}),
      (p2:Product {productId:'CH24-SIM-P2'}),
      (p3:Product {productId:'CH24-SIM-P3'}),
      (p4:Product {productId:'CH24-SIM-P4'})
CREATE (c1)-[:VIEWED]->(p1), (c1)-[:VIEWED]->(p2), (c1)-[:VIEWED]->(p3),
       (c2)-[:VIEWED]->(p1), (c2)-[:VIEWED]->(p2),
       (c3)-[:VIEWED]->(p3), (c3)-[:VIEWED]->(p4);

RETURN 'C1/C2 Jaccard = 2/3; C1/C3 Jaccard = 1/4' AS manualBaseline;

The manual Jaccard calculation is deterministic: C1 and C2 share P1/P2, so intersection size is 2 and union size is 3. C1 and C3 share only P3 and their union is four products, so Jaccard is 1/4.

4. Node Similarity: neighborhood overlap is the data

CALL gds.graph.project(
  'atlas-ch24-similarity',
  ['CH24SimilarityCustomer','CH24SimilarityProduct'],
  'VIEWED'
) YIELD graphName, nodeCount, relationshipCount;

CALL gds.nodeSimilarity.stream.estimate('atlas-ch24-similarity', {
  similarityMetric:'JACCARD', topK:2, concurrency:2
}) YIELD nodeCount, relationshipCount, requiredMemory
RETURN *;

CALL gds.nodeSimilarity.stream('atlas-ch24-similarity', {
  similarityMetric:'JACCARD',
  similarityCutoff:0.0,
  topK:2,
  concurrency:2
}) YIELD node1, node2, similarity
WITH gds.util.asNode(node1) AS a, gds.util.asNode(node2) AS b, similarity
WHERE a:Customer AND b:Customer
RETURN a.customerId AS customer1, b.customerId AS customer2, similarity
ORDER BY customer1, similarity DESC;

5. Jaccard, Overlap, and Cosine answer different normalization questions

UNWIND ['JACCARD','OVERLAP','COSINE'] AS metric
CALL gds.nodeSimilarity.stats('atlas-ch24-similarity', {
  similarityMetric:metric,
  topK:2,
  concurrency:2
})
YIELD nodesCompared, similarityDistribution
RETURN metric, nodesCompared, similarityDistribution;

6. KNN: candidate generation from projected properties

KNN is not a replacement for vector indexes from Chapter 22; here it is a GDS algorithm over projected properties. The first-neighbor sampling and iterative candidate refinement make KNN approximate. Treat recall against a small exact baseline as evidence, not the returned score alone.

CALL gds.graph.project(
  'atlas-ch24-knn',
  {CH24SimilarityProduct:{properties:['featureVec']}},
  '*'
) YIELD graphName, nodeCount, relationshipCount;

CALL gds.knn.stream('atlas-ch24-knn', {
  nodeProperties:[{featureVec:'COSINE'}],
  topK:2,
  randomSeed:24,
  concurrency:2
})
YIELD node1, node2, similarity
RETURN gds.util.asNode(node1).productId AS product1,
       gds.util.asNode(node2).productId AS product2,
       similarity
ORDER BY product1, similarity DESC;

Only compare results for the intended CH24-SIM- products. If other Product nodes are still present, the projection is too broad for the lab; filter it or reset first.

7. Deliberately wrong: similarity means “users will buy the same thing”

Structural similarity is association in the selected graph. It can be confounded by popularity, sparse activity, campaign exposure, geography, or data collection. The repair is a candidate pipeline: generate candidates, apply eligibility/business/security filters, rank with separate features, then evaluate against future or held-out outcomes. Similarity is one feature, not a causal claim.

Production judgment and bridge

Next, the output is no longer a score or pair but a route/reachability structure. Path algorithms make weight semantics even stricter because “cost” must compose along a path.

Summary and next step

Node Similarity, KNN, Jaccard/Overlap/Cosine Concepts, and Candidate Generation is useful only when its assumptions and observed evidence stay attached to the decision. The examples above establish a reproducible mechanism and boundary; they do not turn one lab result into a universal production rule.

Next, continue to Pathfinding and Spanning/Reachability Algorithms: When GDS Beats Transactional Cypher. Carry forward the verified assumptions, fixture state, version/edition boundaries, and measurements from this lesson instead of treating the next topic as an isolated recipe.

Authoritative references

• GDS Manual v2026.07 — Current Graph Data Science manual and release baseline.
• GDS supported Neo4j versions — Compatibility matrix mapping Neo4j 2026.07 to GDS 2026.07.
• GDS editions — Community includes all algorithms but caps concurrency at four CPU cores and the model catalog at three models; Enterprise adds operational capabilities.
• Algorithm syntax and execution modes — stream/stats/mutate/write/estimate semantics and common algorithm configuration.
• Memory estimation — Estimate memory before allocating algorithm working state.
• Centrality algorithms — Current centrality family and quality tiers.
• Degree Centrality — Degree semantics and weighted/directed behavior.
• PageRank — PageRank iteration, damping, weights, and execution modes.
• Betweenness Centrality — Exact/sampled betweenness, samplingSize/samplingSeed, memory and concurrency tradeoffs.
• Eigenvector Centrality — Transitive influence and power-iteration semantics.
• Louvain — Modularity, levels, tolerance, seeding and execution modes.
• Leiden — Community detection with gamma, theta, randomSeed and connectivity refinement.
• Label Propagation — Fast topology-driven community detection, optional weights and seeds.
• Node Similarity — Structural neighborhood similarity with Jaccard, Overlap, or Cosine.
• K-Nearest Neighbors — Property-based approximate KNN and supported metrics.
• Path finding algorithms — Current shortest path, traversal, spanning, and flow families.
• Dijkstra Source-Target — Positive-cost shortest path semantics; sourceNode/targetNodes current syntax.
• Breadth First Search — Reachability traversal, targets, maxDepth, and stream/mutate modes.
• Graph algorithm operations reference — Current procedure/function names including spanningTree and similarity functions.
• Neo4j current versions — Current Neo4j database release and 5.26 LTS line.