fix(cugraph): filter isolated nodes and remap indices for all algorithms

cuGraph requires contiguous vertex indices starting from 0. When a graph
contains isolated nodes (nodes with no edges), the Memgraph GraphView
includes them but cuGraph's internal renumbering excludes them, causing
array index mismatches and "Index out of range" crashes.

Solution:
- CreateCugraphFromMemgraph now filters nodes with degree 0 before
  building the cuGraph edge list
- Returns a renumber_map that maps cuGraph's contiguous indices back
  to the original GraphView node indices
- All algorithms updated to use renumber_map when translating results
  back to Memgraph node IDs

Example: Graph with 137,852 nodes but only 108,024 have edges.
Previously crashed. Now correctly processes 108,024 connected nodes.

Affected algorithms: betweenness_centrality, pagerank, hits,
katz_centrality, louvain, leiden, personalized_pagerank,
spectral_clustering

Author: TheReaperJay

.gitignore

@@ -208,4 +208,5 @@ python/mage/link_prediction/random_customer_results.txt
 python/mage/link_prediction/cora_results.txt
 python/mage/link_prediction/random_features_services_results.txt
 python/mage/link_prediction/issue.py
-python/mage/link_prediction/issue2.py
+python/mage/link_prediction/issue2.py.build-staging/
+rebuild-cugraph.sh

cpp/cugraph_module/algorithms/betweenness_centrality.cu

@@ -30,7 +30,7 @@ constexpr char const *kArgumentDirected = "directed";
 constexpr char const *kArgumentK = "k";
 
 constexpr char const *kResultFieldNode = "node";
-constexpr char const *kResultFieldBetweenness = "betweenness";
+constexpr char const *kResultFieldBetweennessCentrality = "betweenness_centrality";
 
 void InsertBetweennessRecord(mgp_graph *graph, mgp_result *result, mgp_memory *memory, const std::uint64_t node_id,
                              double betweenness) {
@@ -46,7 +46,7 @@ void InsertBetweennessRecord(mgp_graph *graph, mgp_result *result, mgp_memory *m
   if (record == nullptr) throw mg_exception::NotEnoughMemoryException();
 
   mg_utility::InsertNodeValueResult(record, kResultFieldNode, node, memory);
-  mg_utility::InsertDoubleValueResult(record, kResultFieldBetweenness, betweenness, memory);
+  mg_utility::InsertDoubleValueResult(record, kResultFieldBetweennessCentrality, betweenness, memory);
 }
 
 void BetweennessCentralityProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mgp_memory *memory) {
@@ -64,7 +64,7 @@ void BetweennessCentralityProc(mgp_list *args, mgp_graph *graph, mgp_result *res
     auto stream = handle.get_stream();
 
     // Betweenness centrality uses store_transposed = false
-    auto [cu_graph, edge_props] = mg_cugraph::CreateCugraphFromMemgraph<vertex_t, edge_t, weight_t, false, false>(
+    auto [cu_graph, edge_props, renumber_map] = mg_cugraph::CreateCugraphFromMemgraph<vertex_t, edge_t, weight_t, false, false>(
         *mg_graph.get(), graph_type, handle);
 
     auto cu_graph_view = cu_graph.view();
@@ -121,8 +121,10 @@ void BetweennessCentralityProc(mgp_list *args, mgp_graph *graph, mgp_result *res
     raft::update_host(h_betweenness.data(), betweenness.data(), n_vertices, stream);
     handle.sync_stream();
 
+    // Use renumber_map to translate cuGraph indices back to original GraphView indices
     for (vertex_t node_id = 0; node_id < static_cast<vertex_t>(n_vertices); ++node_id) {
-      InsertBetweennessRecord(graph, result, memory, mg_graph->GetMemgraphNodeId(node_id), h_betweenness[node_id]);
+      auto original_id = renumber_map[node_id];
+      InsertBetweennessRecord(graph, result, memory, mg_graph->GetMemgraphNodeId(original_id), h_betweenness[node_id]);
     }
   } catch (const std::exception &e) {
     // We must not let any exceptions out of our module.
@@ -150,7 +152,7 @@ extern "C" int mgp_init_module(struct mgp_module *module, struct mgp_memory *mem
     mgp::proc_add_opt_arg(betweenness_proc, kArgumentK, mgp::type_int(), default_k);
 
     mgp::proc_add_result(betweenness_proc, kResultFieldNode, mgp::type_node());
-    mgp::proc_add_result(betweenness_proc, kResultFieldBetweenness, mgp::type_float());
+    mgp::proc_add_result(betweenness_proc, kResultFieldBetweennessCentrality, mgp::type_float());
   } catch (const std::exception &e) {
     mgp_value_destroy(default_normalized);
     mgp_value_destroy(default_directed);

cpp/cugraph_module/algorithms/hits.cu

@@ -25,11 +25,11 @@ constexpr char const *kProcedureHits = "get";
 
 constexpr char const *kArgumentMaxIterations = "max_iterations";
 constexpr char const *kArgumentTolerance = "tolerance";
-constexpr char const *kArgumentNormalize = "normalize";
+constexpr char const *kArgumentNormalized = "normalized";
 
 constexpr char const *kResultFieldNode = "node";
-constexpr char const *kResultFieldHub = "hub";
-constexpr char const *kResultFieldAuthority = "authority";
+constexpr char const *kResultFieldHubScore = "hubs";
+constexpr char const *kResultFieldAuthoritiesScore = "authorities";
 
 void InsertHitsRecord(mgp_graph *graph, mgp_result *result, mgp_memory *memory, const std::uint64_t node_id,
                       double hub, double authority) {
@@ -45,8 +45,8 @@ void InsertHitsRecord(mgp_graph *graph, mgp_result *result, mgp_memory *memory,
   if (record == nullptr) throw mg_exception::NotEnoughMemoryException();
 
   mg_utility::InsertNodeValueResult(record, kResultFieldNode, node, memory);
-  mg_utility::InsertDoubleValueResult(record, kResultFieldHub, hub, memory);
-  mg_utility::InsertDoubleValueResult(record, kResultFieldAuthority, authority, memory);
+  mg_utility::InsertDoubleValueResult(record, kResultFieldHubScore, hub, memory);
+  mg_utility::InsertDoubleValueResult(record, kResultFieldAuthoritiesScore, authority, memory);
 }
 
 void HitsProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mgp_memory *memory) {
@@ -63,7 +63,7 @@ void HitsProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mgp_memory *
     auto stream = handle.get_stream();
 
     // HITS requires store_transposed = true
-    auto [cu_graph, edge_props] = mg_cugraph::CreateCugraphFromMemgraph<vertex_t, edge_t, weight_t, true, false>(
+    auto [cu_graph, edge_props, renumber_map] = mg_cugraph::CreateCugraphFromMemgraph<vertex_t, edge_t, weight_t, true, false>(
         *mg_graph.get(), mg_graph::GraphType::kDirectedGraph, handle);
 
     auto cu_graph_view = cu_graph.view();
@@ -92,8 +92,10 @@ void HitsProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mgp_memory *
     raft::update_host(h_authorities.data(), authorities.data(), n_vertices, stream);
     handle.sync_stream();
 
+    // Use renumber_map to translate cuGraph indices back to original GraphView indices
     for (vertex_t node_id = 0; node_id < static_cast<vertex_t>(n_vertices); ++node_id) {
-      InsertHitsRecord(graph, result, memory, mg_graph->GetMemgraphNodeId(node_id), h_hubs[node_id],
+      auto original_id = renumber_map[node_id];
+      InsertHitsRecord(graph, result, memory, mg_graph->GetMemgraphNodeId(original_id), h_hubs[node_id],
                        h_authorities[node_id]);
     }
   } catch (const std::exception &e) {
@@ -117,11 +119,11 @@ extern "C" int mgp_init_module(struct mgp_module *module, struct mgp_memory *mem
 
     mgp::proc_add_opt_arg(hits_proc, kArgumentMaxIterations, mgp::type_int(), default_max_iterations);
     mgp::proc_add_opt_arg(hits_proc, kArgumentTolerance, mgp::type_float(), default_tolerance);
-    mgp::proc_add_opt_arg(hits_proc, kArgumentNormalize, mgp::type_bool(), default_normalize);
+    mgp::proc_add_opt_arg(hits_proc, kArgumentNormalized, mgp::type_bool(), default_normalize);
 
     mgp::proc_add_result(hits_proc, kResultFieldNode, mgp::type_node());
-    mgp::proc_add_result(hits_proc, kResultFieldHub, mgp::type_float());
-    mgp::proc_add_result(hits_proc, kResultFieldAuthority, mgp::type_float());
+    mgp::proc_add_result(hits_proc, kResultFieldHubScore, mgp::type_float());
+    mgp::proc_add_result(hits_proc, kResultFieldAuthoritiesScore, mgp::type_float());
   } catch (const std::exception &e) {
     mgp_value_destroy(default_max_iterations);
     mgp_value_destroy(default_tolerance);

cpp/cugraph_module/algorithms/katz_centrality.cu

@@ -27,10 +27,10 @@ constexpr char const *kArgumentAlpha = "alpha";
 constexpr char const *kArgumentBeta = "beta";
 constexpr char const *kArgumentEpsilon = "epsilon";
 constexpr char const *kArgumentMaxIterations = "max_iterations";
-constexpr char const *kArgumentNormalize = "normalize";
+constexpr char const *kArgumentNormalized = "normalized";
 
 constexpr char const *kResultFieldNode = "node";
-constexpr char const *kResultFieldKatz = "katz";
+constexpr char const *kResultFieldKatzCentrality = "katz_centrality";
 
 const double kDefaultWeight = 1.0;
 
@@ -48,7 +48,7 @@ void InsertKatzRecord(mgp_graph *graph, mgp_result *result, mgp_memory *memory,
   if (record == nullptr) throw mg_exception::NotEnoughMemoryException();
 
   mg_utility::InsertNodeValueResult(record, kResultFieldNode, node, memory);
-  mg_utility::InsertDoubleValueResult(record, kResultFieldKatz, katz, memory);
+  mg_utility::InsertDoubleValueResult(record, kResultFieldKatzCentrality, katz, memory);
 }
 
 void KatzCentralityProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mgp_memory *memory) {
@@ -57,7 +57,7 @@ void KatzCentralityProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mg
     auto beta = mgp::value_get_double(mgp::list_at(args, 1));
     auto epsilon = mgp::value_get_double(mgp::list_at(args, 2));
     auto max_iterations = static_cast<std::size_t>(mgp::value_get_int(mgp::list_at(args, 3)));
-    auto normalize = mgp::value_get_bool(mgp::list_at(args, 4));
+    auto normalized = mgp::value_get_bool(mgp::list_at(args, 4));
 
     auto mg_graph = mg_utility::GetGraphView(graph, result, memory, mg_graph::GraphType::kDirectedGraph);
     if (mg_graph->Empty()) return;
@@ -67,7 +67,7 @@ void KatzCentralityProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mg
     auto stream = handle.get_stream();
 
     // Katz centrality requires store_transposed = true
-    auto [cu_graph, edge_props] = mg_cugraph::CreateCugraphFromMemgraph<vertex_t, edge_t, weight_t, true, false>(
+    auto [cu_graph, edge_props, renumber_map] = mg_cugraph::CreateCugraphFromMemgraph<vertex_t, edge_t, weight_t, true, false>(
         *mg_graph.get(), mg_graph::GraphType::kDirectedGraph, handle);
 
     auto cu_graph_view = cu_graph.view();
@@ -91,16 +91,18 @@ void KatzCentralityProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mg
         static_cast<result_t>(epsilon),
         max_iterations,
         false,     // has_initial_guess
-        normalize,
+        normalized,
         false);    // do_expensive_check
 
     // Copy results to host and output
     std::vector<result_t> h_katz(n_vertices);
     raft::update_host(h_katz.data(), katz_centralities.data(), n_vertices, stream);
     handle.sync_stream();
 
+    // Use renumber_map to translate cuGraph indices back to original GraphView indices
     for (vertex_t node_id = 0; node_id < static_cast<vertex_t>(n_vertices); ++node_id) {
-      InsertKatzRecord(graph, result, memory, mg_graph->GetMemgraphNodeId(node_id), h_katz[node_id]);
+      auto original_id = renumber_map[node_id];
+      InsertKatzRecord(graph, result, memory, mg_graph->GetMemgraphNodeId(original_id), h_katz[node_id]);
     }
   } catch (const std::exception &e) {
     // We must not let any exceptions out of our module.
@@ -115,38 +117,38 @@ extern "C" int mgp_init_module(struct mgp_module *module, struct mgp_memory *mem
   mgp_value *default_beta;
   mgp_value *default_epsilon;
   mgp_value *default_max_iterations;
-  mgp_value *default_normalize;
+  mgp_value *default_normalized;
   try {
     auto *katz_proc = mgp::module_add_read_procedure(module, kProcedureKatzCentrality, KatzCentralityProc);
 
     default_alpha = mgp::value_make_double(0.1, memory);
     default_beta = mgp::value_make_double(1.0, memory);
     default_epsilon = mgp::value_make_double(1e-6, memory);
     default_max_iterations = mgp::value_make_int(100, memory);
-    default_normalize = mgp::value_make_bool(false, memory);
+    default_normalized = mgp::value_make_bool(false, memory);
 
     mgp::proc_add_opt_arg(katz_proc, kArgumentAlpha, mgp::type_float(), default_alpha);
     mgp::proc_add_opt_arg(katz_proc, kArgumentBeta, mgp::type_float(), default_beta);
     mgp::proc_add_opt_arg(katz_proc, kArgumentEpsilon, mgp::type_float(), default_epsilon);
     mgp::proc_add_opt_arg(katz_proc, kArgumentMaxIterations, mgp::type_int(), default_max_iterations);
-    mgp::proc_add_opt_arg(katz_proc, kArgumentNormalize, mgp::type_bool(), default_normalize);
+    mgp::proc_add_opt_arg(katz_proc, kArgumentNormalized, mgp::type_bool(), default_normalized);
 
     mgp::proc_add_result(katz_proc, kResultFieldNode, mgp::type_node());
-    mgp::proc_add_result(katz_proc, kResultFieldKatz, mgp::type_float());
+    mgp::proc_add_result(katz_proc, kResultFieldKatzCentrality, mgp::type_float());
   } catch (const std::exception &e) {
     mgp_value_destroy(default_alpha);
     mgp_value_destroy(default_beta);
     mgp_value_destroy(default_epsilon);
     mgp_value_destroy(default_max_iterations);
-    mgp_value_destroy(default_normalize);
+    mgp_value_destroy(default_normalized);
     return 1;
   }
 
   mgp_value_destroy(default_alpha);
   mgp_value_destroy(default_beta);
   mgp_value_destroy(default_epsilon);
   mgp_value_destroy(default_max_iterations);
-  mgp_value_destroy(default_normalize);
+  mgp_value_destroy(default_normalized);
   return 0;
 }
 

cpp/cugraph_module/algorithms/leiden.cu

@@ -60,7 +60,7 @@ void LeidenProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mgp_memory
     auto stream = handle.get_stream();
 
     // Leiden requires store_transposed = false
-    auto [cu_graph, edge_props] = mg_cugraph::CreateCugraphFromMemgraph<vertex_t, edge_t, weight_t, false, false>(
+    auto [cu_graph, edge_props, renumber_map] = mg_cugraph::CreateCugraphFromMemgraph<vertex_t, edge_t, weight_t, false, false>(
         *mg_graph.get(), mg_graph::GraphType::kUndirectedGraph, handle);
 
     auto cu_graph_view = cu_graph.view();
@@ -92,8 +92,10 @@ void LeidenProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mgp_memory
     raft::update_host(h_clustering.data(), clustering_result.data(), n_vertices, stream);
     handle.sync_stream();
 
+    // Use renumber_map to translate cuGraph indices back to original GraphView indices
     for (vertex_t node_id = 0; node_id < static_cast<vertex_t>(n_vertices); ++node_id) {
-      InsertLeidenRecord(graph, result, memory, mg_graph->GetMemgraphNodeId(node_id), h_clustering[node_id]);
+      auto original_id = renumber_map[node_id];
+      InsertLeidenRecord(graph, result, memory, mg_graph->GetMemgraphNodeId(original_id), h_clustering[node_id]);
     }
   } catch (const std::exception &e) {
     mgp::result_set_error_msg(result, e.what());

cpp/cugraph_module/algorithms/louvain.cu

@@ -58,7 +58,7 @@ void LouvainProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mgp_memor
     auto stream = handle.get_stream();
 
     // Louvain requires store_transposed = false
-    auto [cu_graph, edge_props] = mg_cugraph::CreateCugraphFromMemgraph<vertex_t, edge_t, weight_t, false, false>(
+    auto [cu_graph, edge_props, renumber_map] = mg_cugraph::CreateCugraphFromMemgraph<vertex_t, edge_t, weight_t, false, false>(
         *mg_graph.get(), mg_graph::GraphType::kUndirectedGraph, handle);
 
     auto cu_graph_view = cu_graph.view();
@@ -90,8 +90,10 @@ void LouvainProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mgp_memor
     raft::update_host(h_clustering.data(), clustering_result.data(), n_vertices, stream);
     handle.sync_stream();
 
+    // Use renumber_map to translate cuGraph indices back to original GraphView indices
     for (vertex_t node_id = 0; node_id < static_cast<vertex_t>(n_vertices); ++node_id) {
-      InsertLouvainRecord(graph, result, memory, mg_graph->GetMemgraphNodeId(node_id), h_clustering[node_id]);
+      auto original_id = renumber_map[node_id];
+      InsertLouvainRecord(graph, result, memory, mg_graph->GetMemgraphNodeId(original_id), h_clustering[node_id]);
     }
   } catch (const std::exception &e) {
     mgp::result_set_error_msg(result, e.what());

cpp/cugraph_module/algorithms/pagerank.cu

@@ -61,7 +61,7 @@ void PagerankProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mgp_memo
     auto stream = handle.get_stream();
 
     // PageRank requires store_transposed = true
-    auto [cu_graph, edge_props] = mg_cugraph::CreateCugraphFromMemgraph<vertex_t, edge_t, weight_t, true, false>(
+    auto [cu_graph, edge_props, renumber_map] = mg_cugraph::CreateCugraphFromMemgraph<vertex_t, edge_t, weight_t, true, false>(
         *mg_graph.get(), mg_graph::GraphType::kDirectedGraph, handle);
 
     auto cu_graph_view = cu_graph.view();
@@ -88,8 +88,10 @@ void PagerankProc(mgp_list *args, mgp_graph *graph, mgp_result *result, mgp_memo
     raft::update_host(h_pageranks.data(), pageranks.data(), n_vertices, stream);
     handle.sync_stream();
 
+    // Use renumber_map to translate cuGraph indices back to original GraphView indices
     for (vertex_t node_id = 0; node_id < static_cast<vertex_t>(n_vertices); ++node_id) {
-      InsertPagerankRecord(graph, result, memory, mg_graph->GetMemgraphNodeId(node_id), h_pageranks[node_id]);
+      auto original_id = renumber_map[node_id];
+      InsertPagerankRecord(graph, result, memory, mg_graph->GetMemgraphNodeId(original_id), h_pageranks[node_id]);
     }
   } catch (const std::exception &e) {
     mgp::result_set_error_msg(result, e.what());