diff --git a/notebooks/README.md b/notebooks/README.md
index 90bbd8142d4..d17edb8f129 100644
--- a/notebooks/README.md
+++ b/notebooks/README.md
@@ -16,12 +16,12 @@ This repository contains a collection of Jupyter Notebooks that outline how to r
 |                 | [Degree](algorithms/centrality/Degree.ipynb)                 | Compute Degree Centraility for each vertex                   |
 |                 | [Eigenvector](algorithms/centrality/Eigenvector.ipynb)       | Compute Eigenvector for every vertex                         |
 | Community       |                                                              |                                                              |
-|                 | [Louvain](community/Louvain.ipynb) and Leiden                          | Identify clusters in a graph using both the Louvain and Leiden algorithms     |
-|                 | [ECG](community/ECG.ipynb)                                   | Identify clusters in a graph using the Ensemble Clustering for Graph |
-|                 | [K-Truss](community/ktruss.ipynb)                                | Extracts the K-Truss cluster                                 |
-|                 | [Spectral-Clustering](community/Spectral-Clustering.ipynb)   | Identify clusters in a  graph using Spectral Clustering with both<br> - Balanced Cut<br> - Modularity Modularity |
-|                 | [Subgraph Extraction](community/Subgraph-Extraction.ipynb)   | Compute a subgraph of the existing graph including only the specified vertices |
-|                 | [Triangle Counting](community/Triangle-Counting.ipynb)       | Count the number of Triangle in a graph                      |
+|                 | [Louvain](algorithms/community/Louvain.ipynb) and Leiden                          | Identify clusters in a graph using both the Louvain and Leiden algorithms     |
+|                 | [ECG](algorithms/community/ECG.ipynb)                                   | Identify clusters in a graph using the Ensemble Clustering for Graph |
+|                 | [K-Truss](algorithms/community/ktruss.ipynb)                                | Extracts the K-Truss cluster                                 |
+|                 | [Spectral-Clustering](algorithms/community/Spectral-Clustering.ipynb)   | Identify clusters in a  graph using Spectral Clustering with both<br> - Balanced Cut<br> - Modularity Modularity |
+|                 | [Subgraph Extraction](algorithms/community/Subgraph-Extraction.ipynb)   | Compute a subgraph of the existing graph including only the specified vertices |
+|                 | [Triangle Counting](algorithms/community/Triangle-Counting.ipynb)       | Count the number of Triangle in a graph                      |
 | Components      |                                                              |                                                              |
 |                 | [Connected Components](components/ConnectedComponents.ipynb) | Find weakly and strongly connected components in a graph     |
 | Core            |                                                              |                                                              |
diff --git a/notebooks/algorithms/README.md b/notebooks/algorithms/README.md
index 14b2929efac..bf0d6a3b27a 100644
--- a/notebooks/algorithms/README.md
+++ b/notebooks/algorithms/README.md
@@ -16,15 +16,14 @@ This repository contains a collection of Jupyter Notebooks that outline how to r
 |                 | [Betweenness](centrality/Betweenness.ipynb)                  | Compute both Edge and Vertex Betweenness centrality          |
 |                 | [Degree](centrality/Degree.ipynb)                            | Compute Degree Centraility for each vertex                   |
 |                 | [Eigenvector](centrality/Eigenvector.ipynb)                  | Compute Eigenvector for every vertex                         |
-
-<!-- | Community       |                                                              |                                                              |
+| Community       |                                                              |                                                              |
 |                 | [Louvain](community/Louvain.ipynb) and Leiden                          | Identify clusters in a graph using both the Louvain and Leiden algorithms     |
 |                 | [ECG](community/ECG.ipynb)                                   | Identify clusters in a graph using the Ensemble Clustering for Graph |
 |                 | [K-Truss](community/ktruss.ipynb)                                | Extracts the K-Truss cluster                                 |
 |                 | [Spectral-Clustering](community/Spectral-Clustering.ipynb)   | Identify clusters in a  graph using Spectral Clustering with both<br> - Balanced Cut<br> - Modularity Modularity |
 |                 | [Subgraph Extraction](community/Subgraph-Extraction.ipynb)   | Compute a subgraph of the existing graph including only the specified vertices |
 |                 | [Triangle Counting](community/Triangle-Counting.ipynb)       | Count the number of Triangle in a graph                      |
-| Components      |                                                              |                                                              |
+<!--| Components      |                                                              |                                                              |
 |                 | [Connected Components](components/ConnectedComponents.ipynb) | Find weakly and strongly connected components in a graph     |
 | Core            |                                                              |                                                              |
 |                 | [K-Core](cores/kcore.ipynb)                                  | Extracts the K-core cluster                                  |
diff --git a/notebooks/algorithms/centrality/README.md b/notebooks/algorithms/centrality/README.md
index 608dd239029..6f116094b15 100644
--- a/notebooks/algorithms/centrality/README.md
+++ b/notebooks/algorithms/centrality/README.md
@@ -15,11 +15,11 @@ But which vertices are most important? The answer depends on which measure/algor
 
 |Algorithm          |Notebooks Containing                                                     |Description                                                  |
 | --------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
-|Degree Centrality| [Centrality](centrality/Centrality.ipynb), [Degree](centrality/Degree.ipynb)                   |Measure based on counting direct connections for each vertex|
-|Betweenness Centrality| [Centrality](centrality/Centrality.ipynb), [Betweenness](centrality/Betweenness.ipynb)                    |Number of shortest paths through the vertex|
-|Eigenvector Centrality|[Centrality](centrality/Centrality.ipynb), [Eigenvector](centrality/Eigenvector.ipynb)|Measure of connectivity to other important vertices (which also have high connectivity) often referred to as the influence measure of a vertex|
-|Katz Centrality|[Centrality](centrality/Centrality.ipynb), [Katz](centrality/Katz.ipynb)                                         |Similar to Eigenvector but has tweaks to measure more weakly connected graph  |
-|Pagerank|[Centrality](centrality/Centrality.ipynb), [Pagerank](../../link_analysis/Pagerank.ipynb)                                         |Classified as both a link analysis and centrality measure by quantifying incoming links from central vertices.  |
+|Degree Centrality| [Centrality](./Centrality.ipynb), [Degree](centrality/Degree.ipynb)                   |Measure based on counting direct connections for each vertex|
+|Betweenness Centrality| [Centrality](./Centrality.ipynb), [Betweenness](centrality/Betweenness.ipynb)                    |Number of shortest paths through the vertex|
+|Eigenvector Centrality|[Centrality](./Centrality.ipynb), [Eigenvector](./Eigenvector.ipynb)|Measure of connectivity to other important vertices (which also have high connectivity) often referred to as the influence measure of a vertex|
+|Katz Centrality|[Centrality](./Centrality.ipynb), [Katz](./Katz.ipynb)                                         |Similar to Eigenvector but has tweaks to measure more weakly connected graph  |
+|Pagerank|[Centrality](./Centrality.ipynb), [Pagerank](../../link_analysis/Pagerank.ipynb)                                         |Classified as both a link analysis and centrality measure by quantifying incoming links from central vertices.  |
 
 [System Requirements](../../README.md#requirements)
 
diff --git a/notebooks/algorithms/community/Community-Clustering.ipynb b/notebooks/algorithms/community/Community-Clustering.ipynb
new file mode 100644
index 00000000000..8ff14c66c95
--- /dev/null
+++ b/notebooks/algorithms/community/Community-Clustering.ipynb
@@ -0,0 +1,393 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Community Clustering"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this notebook, we will cluster the graph using various algorithms implemented in cuGraph.  We will then compare the clusters resulting from each algorithm.\n",
+    "\n",
+    "| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware |\n",
+    "| --------------|------------|------------------|-----------------|----------------|\n",
+    "| Don Acosta    | 07/05/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Clustering is the analytic method for finding the highly connected sets of vertices within a graph. It is often used to answer questions like:\n",
+    "\n",
+    "* What are the communities within this graph?\n",
+    "* How can the graph be cut into the most cohesive partitions?\n",
+    "* What is the most important group of vertices within this group?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Test Data\n",
+    "We will be using the Zachary Karate club dataset \n",
+    "*W. W. Zachary, An information flow model for conflict and fission in small groups, Journal of\n",
+    "Anthropological Research 33, 452-473 (1977).*\n",
+    "\n",
+    "\n",
+    "<img src=\"../../img/zachary_graph_clusters.png\" width=\"35%\"/>\n",
+    "\n",
+    "Because the test data has vertex IDs starting at 1, the auto-renumber feature of cuGraph (mentioned above) will be used so the starting vertex ID is zero for maximum efficiency. The resulting data will then be auto-unrenumbered, making the entire renumbering process transparent to users."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#  Import the cugraph modules\n",
+    "import cugraph\n",
+    "import cudf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import non cugraph modules\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Compute clusters\n",
+    "# the clustering calls are very straightforward with the graph being the primary argument\n",
+    "# we are specifying a few optional parameters for this dataset.\n",
+    "\n",
+    "def compute_clusters(_graph) :\n",
+    "\n",
+    "    # Compute ECG Clusters and normalize the column names\n",
+    "    _e = cugraph.ecg(_graph).rename(columns={'partition': 'cluster'})\n",
+    "    \n",
+    "    # Compute Louvain Clusters \n",
+    "    _l, modularity = cugraph.louvain(_graph)\n",
+    "    # Normalize the column names\n",
+    "    _l = _l.rename(columns={'partition': 'cluster'})\n",
+    "\n",
+    "    # Compute Spectral Balanced Clusters\n",
+    "    _b = cugraph.spectralBalancedCutClustering(_graph, 4, num_eigen_vects=4)\n",
+    "\n",
+    "    # Call spectralModularityMaximizationClustering on the graph for 3 clusterstral \n",
+    "    _m = cugraph.spectralModularityMaximizationClustering(_graph, 4, num_eigen_vects=4)\n",
+    "    return _e, _l, _b, _m"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# compare 2 cluster results\n",
+    "def compare_values(algo, v1, v2):\n",
+    "    return (algo.loc[algo['vertex'] == v1]['cluster'].reset_index(drop=True)).equals((algo.loc[algo['vertex'] == v2]['cluster'].reset_index(drop=True)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This functon builds a matrix to identify which algorithms cluster pairs of vertices together."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_cluster_matrix(ecg, louvain, spec_balance, spec_mod):\n",
+    "    mat_size = ecg['vertex'].max()\n",
+    "    clust_matrix = np.empty((mat_size+1) * (mat_size+1), dtype='object')\n",
+    "    clust_matrix = clust_matrix.reshape((mat_size+1),(mat_size+1))\n",
+    "\n",
+    "    type(ecg['vertex'])\n",
+    "\n",
+    "    for id_1 in ecg['vertex'].to_pandas():\n",
+    "        for id_2 in ecg['vertex'].to_pandas():\n",
+    "            clust_matrix[id_1][id_2] = \"\"\n",
+    "            if id_2 > id_1:\n",
+    "                if compare_values(ecg, id_1, id_2):\n",
+    "                    clust_matrix[id_1][id_2] += \"e\"\n",
+    "                if compare_values(louvain, id_1, id_2):\n",
+    "                    clust_matrix[id_1][id_2] += \"l\"\n",
+    "                if compare_values(spec_balance, id_1, id_2):\n",
+    "                    clust_matrix[id_1][id_2] += \"b\"\n",
+    "                if compare_values(spec_mod, id_1, id_2):\n",
+    "                    clust_matrix[id_1][id_2] += \"m\"\n",
+    "\n",
+    "    return clust_matrix   "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Method to look at a vertex pair since only one half of the symetric matrix is calculated for efficiency and display purposes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def pair_clustering(comp_matrix, id1, id2):\n",
+    "    if (id2 > id1):\n",
+    "        return comp_matrix[id1][id2]\n",
+    "    else:\n",
+    "         return comp_matrix[id2][id1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Print the table showing which algorithms group which vertices together"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def print_clustering_table(cluster_array):\n",
+    "    import pandas as pd\n",
+    "    from IPython.display import display_html\n",
+    "    df = pd.DataFrame(cluster_array)\n",
+    "    df_styler = df.drop(df.columns[[0]], axis=1).drop(0).style.set_table_attributes(\"style='display:inline'\")\n",
+    "    display_html(df_styler._repr_html_(), raw=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Read the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test file    \n",
+    "datafile='../../data/karate-data.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# read the data using cuDF\n",
+    "gdf = cudf.read_csv(datafile, delimiter='\\t', names=['src', 'dst'], dtype=['int32', 'int32'] )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The algorithms often also require that there are vertex weights.  Just use 1.0 \n",
+    "gdf[\"data\"] = 1.0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "it was that easy to load data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create a Graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create a Graph - since the data does not start at '0', use the auto-renumbering feature\n",
+    "G = cugraph.Graph()\n",
+    "G.from_cudf_edgelist(gdf, source='src', destination='dst', edge_attr='data', renumber=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Now do all the clustering"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "_e, _l, _b, _m = compute_clusters(G)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "View the clusters for a single algorithm, in this case Ensemble Graph Clustering"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "_e.to_pandas().groupby('cluster')['vertex'].apply(list)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Generate the cluster comparison matrix to view the results of the clustering algorithms in one structure. Notice, the first row and column are index 0 which is empty since the graph has been numbered/renumbered to start with 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "clust_comparison = create_cluster_matrix(_e, _l, _b, _m)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "print the entire algorithm clustering comparison table.\n",
+    "\n",
+    "The matrix[i][j] element includes a list of the algorithms where i and j are clustered together:\n",
+    "* e = Ensemble Graph Clustering has placed i and j together in a cluster\n",
+    "* l = Louvain community detection has placed i and j together in a cluster\n",
+    "* b = Spectral Balanced Clustering has placed i and j together in a cluster\n",
+    "* m = Spectral Modularity Maximization Clustering has placed i and j together in a cluster.\n",
+    "\n",
+    "See how the clustering algorithims align with the structure of the graph:\n",
+    "\n",
+    "<img src=\"../../img/zachary_graph_clusters.png\" width=\"35%\"/>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print_clustering_table(clust_comparison)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "An individual point in matrix, clust_comparison(5,17) shows that ECG, Louvain and spectral balanced clustering put vertices 5 and 17 in the same cluster, but Spectral Modularity Maximization does not."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(pair_clustering(clust_comparison,17,5))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, to see the full clustering of a single algorithm, do the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "_e.to_pandas().groupby('cluster')['vertex'].apply(list)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "___\n",
+    "Copyright (c) 2022, NVIDIA CORPORATION.\n",
+    "\n",
+    "Licensed under the Apache License, Version 2.0 (the \"License\");  you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n",
+    "\n",
+    "Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.\n",
+    "___"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.8.13 ('cugraph_dev')",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.13"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "cee8a395f2f0c5a5bcf513ae8b620111f4346eff6dc64e1ea99c951b2ec68604"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/community/ECG.ipynb b/notebooks/algorithms/community/ECG.ipynb
similarity index 91%
rename from notebooks/community/ECG.ipynb
rename to notebooks/algorithms/community/ECG.ipynb
index 9a35b135570..28d44f5e3b2 100644
--- a/notebooks/community/ECG.ipynb
+++ b/notebooks/algorithms/community/ECG.ipynb
@@ -5,7 +5,6 @@
    "metadata": {},
    "source": [
     "# Ensemble Clustering for Graphs (ECG)\n",
-    "# Does not run on Pascal\n",
     "In this notebook, we will use cuGraph to identify the cluster in a test graph using the Ensemble Clustering for Graph approach.  \n",
     "\n",
     "| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware        |\n",
@@ -13,8 +12,7 @@
     "| Brad Rees     | 04/24/2020 | created          | 0.6             |                       |\n",
     "|               | 08/16/2020 | updated          | 0.15            | GV100, CUDA 10.2      |\n",
     "|               | 08/05/2021 | tested/updated   | 21.10 nightly   | RTX 3090 CUDA 11.4    |\n",
-    "\n",
-    "RAPIDS release 21.06 does not support Pascal.  Release 21.08 addressed issues and does support Pascal\n",
+    "| Don Acosta    | 07/20/2022 | tested/updated   | 22.08 nightly   | DGX Tesla V100 CUDA 11.5   |\n",
     "\n",
     "## Introduction\n",
     "\n",
@@ -67,7 +65,7 @@
    "metadata": {},
    "source": [
     "#### Some notes about vertex IDs...\n",
-    "* The current version of cuGraph requires that vertex IDs be representable as 32-bit integers, meaning graphs currently can contain at most 2^32 unique vertex IDs. However, this limitation is being actively addressed and a version of cuGraph that accommodates more than 2^32 vertices will be available in the near future.\n",
+    "\n",
     "* cuGraph will automatically renumber graphs to an internal format consisting of a contiguous series of integers starting from 0, and convert back to the original IDs when returning data to the caller. If the vertex IDs of the data are already a contiguous series of integers starting from 0, the auto-renumbering step can be skipped for faster graph creation times.\n",
     "  * To skip auto-renumbering, set the `renumber` boolean arg to `False` when calling the appropriate graph creation API (eg. `G.from_cudf_edgelist(gdf_r, source='src', destination='dst', renumber=False)`).\n",
     "  * For more advanced renumbering support, see the examples in `structure/renumber.ipynb` and `structure/renumber-2.ipynb`\n"
@@ -83,7 +81,7 @@
     "Anthropological Research 33, 452-473 (1977).*\n",
     "\n",
     "\n",
-    "![Karate Club](../img/zachary_black_lines.png)\n",
+    "<img src=\"../../img/zachary_graph_clusters.png\" width=\"35%\"/>\n",
     "\n",
     "Because the test data has vertex IDs starting at 1, the auto-renumber feature of cuGraph (mentioned above) will be used so the starting vertex ID is zero for maximum efficiency. The resulting data will then be auto-unrenumbered, making the entire renumbering process transparent to users.\n"
    ]
@@ -120,7 +118,7 @@
    "outputs": [],
    "source": [
     "# Test file    \n",
-    "datafile='../data//karate-data.csv'"
+    "datafile='../../data/karate-data.csv'"
    ]
   },
   {
@@ -170,7 +168,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Call Louvain on the graph\n",
+    "# Call ecg on the graph\n",
     "df = cugraph.ecg(G) "
    ]
   },
@@ -223,7 +221,7 @@
    "metadata": {},
    "source": [
     "___\n",
-    "Copyright (c) 2019-2020, NVIDIA CORPORATION.\n",
+    "Copyright (c) 2019-2022, NVIDIA CORPORATION.\n",
     "\n",
     "Licensed under the Apache License, Version 2.0 (the \"License\");  you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n",
     "\n",
@@ -234,9 +232,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "cugraph_dev",
+   "display_name": "Python 3.8.13 ('cugraph_dev')",
    "language": "python",
-   "name": "cugraph_dev"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -248,7 +246,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.10"
+   "version": "3.8.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "cee8a395f2f0c5a5bcf513ae8b620111f4346eff6dc64e1ea99c951b2ec68604"
+   }
   }
  },
  "nbformat": 4,
diff --git a/notebooks/community/Louvain.ipynb b/notebooks/algorithms/community/Louvain.ipynb
similarity index 77%
rename from notebooks/community/Louvain.ipynb
rename to notebooks/algorithms/community/Louvain.ipynb
index ce5a550795c..4786fb1e9dc 100755
--- a/notebooks/community/Louvain.ipynb
+++ b/notebooks/algorithms/community/Louvain.ipynb
@@ -9,14 +9,12 @@
     "\n",
     "In this notebook, we will use cuGraph to identify the cluster in a test graph using both the Louvain and Leiden algorithms  \n",
     "\n",
-    "| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware        |\n",
-    "| --------------|------------|------------------|-----------------|-----------------------|\n",
-    "| Brad Rees     | 08/01/2019 | created          | 0.6             |                       |\n",
-    "|               | 08/16/2020 | updated          | 0.14            | GV100, CUDA 10.2      |\n",
-    "|               | 08/05/2021 | tested / updated | 21.10 nightly   | RTX 3090 CUDA 11.4    |\n",
-    "\n",
-    "\n",
-    "RAPIDS release 21.06 does not support Pascal, release 21.08 solved the issue and Pascal is supported again \n",
+    "| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware              |\n",
+    "| --------------|------------|------------------|-----------------|-----------------------------|\n",
+    "| Brad Rees     | 08/01/2019 | created          | 0.6             |                             |\n",
+    "|               | 08/16/2020 | updated          | 0.14            | GV100, CUDA 10.2            |\n",
+    "|               | 08/05/2021 | tested / updated | 21.10 nightly   | RTX 3090 CUDA 11.4          |\n",
+    "| Don Acosta    | 07/11/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5    |\n",
     "\n",
     "\n",
     "\n",
@@ -69,7 +67,7 @@
     "\n",
     "\n",
     "#### Note\n",
-    "Parallel Louvain produces different modularity scores that serial Louvain.\n",
+    "Parallel Louvain produces different modularity scores than serial Louvain.\n",
     "\n",
     "Serial Louvain is a greedy method that iterates over the vertices in numerical order and\n",
     "evaluates whether to move a vertex into a different cluster and then moves it if\n",
@@ -86,13 +84,13 @@
     "is a greedy method, those decisions might lead the algorithms to converge on different local\n",
     "maximums.\n",
     "\n",
-    "A complete technical write-up is being produced and will be linked here when available.  \n",
+    "A complete technical write-up is being produced and will be linked here when available.\n",
     "\n",
     "### References\n",
     "* Blondel, V. D., Guillaume, J.-L., Lambiotte, R., and Lefebvre, E. Fast unfolding of communities in large networks. Journal of statistical mechanics: theory and experiment 2008, 10 (2008), P10008.\n",
     "\n",
     "## Leiden Introduction\n",
-    "Leiden tries to improve upon Louvain by only moving vertices that result in higher quality clusters.  \n",
+    "Leiden tries to improve upon Louvain by only moving vertices that result in higher quality clusters.\n",
     "\n",
     "Leiden has the same set of arguments and return type as Louvain\n",
     "\n",
@@ -106,7 +104,7 @@
    "metadata": {},
    "source": [
     "#### Some notes about vertex IDs...\n",
-    "* The current version of cuGraph requires that vertex IDs be representable as 32-bit integers, meaning graphs currently can contain at most 2^32 unique vertex IDs. However, this limitation is being actively addressed and a version of cuGraph that accommodates more than 2^32 vertices will be available in the near future.\n",
+    "\n",
     "* cuGraph will automatically renumber graphs to an internal format consisting of a contiguous series of integers starting from 0, and convert back to the original IDs when returning data to the caller. If the vertex IDs of the data are already a contiguous series of integers starting from 0, the auto-renumbering step can be skipped for faster graph creation times.\n",
     "  * To skip auto-renumbering, set the `renumber` boolean arg to `False` when calling the appropriate graph creation API (eg. `G.from_cudf_edgelist(gdf_r, source='src', destination='dst', renumber=False)`).\n",
     "  * For more advanced renumbering support, see the examples in `structure/renumber.ipynb` and `structure/renumber-2.ipynb`\n"
@@ -122,7 +120,7 @@
     "Anthropological Research 33, 452-473 (1977).*\n",
     "\n",
     "\n",
-    "![Karate Club](../img/zachary_black_lines.png)\n",
+    "<img src=\"../../img/zachary_graph_clusters.png\" width=\"35%\"/>\n",
     "\n",
     "Because the test data has vertex IDs starting at 1, the auto-renumber feature of cuGraph (mentioned above) will be used so the starting vertex ID is zero for maximum efficiency. The resulting data will then be auto-unrenumbered, making the entire renumbering process transparent to users.\n"
    ]
@@ -136,7 +134,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -154,17 +152,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Test file    \n",
-    "datafile='../data//karate-data.csv'"
+    "datafile='../../data//karate-data.csv'"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -174,7 +172,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -184,23 +182,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "src       int32\n",
-       "dst       int32\n",
-       "data    float64\n",
-       "dtype: object"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# just for fun, let's look at the data types in the dataframe\n",
     "gdf.dtypes"
@@ -208,7 +192,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -219,7 +203,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -229,7 +213,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -239,20 +223,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {
     "scrolled": true
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Louvain Modularity was 0.4155982905982907\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Print the modularity score\n",
     "print('Louvain Modularity was {}'.format(mod))\n",
@@ -261,18 +236,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Leiden Modularity was 0.4155982905982907\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Print the modularity score\n",
     "print('Leiden Modularity was {}'.format(mod_l))\n",
@@ -281,7 +247,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -291,41 +257,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Louvain found 4 partitions\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(\"Louvain found \" + str(len(part_ids)) + \" partitions\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Partition 0:\n",
-      "[32, 25, 26, 29]\n",
-      "Partition 1:\n",
-      "[27, 34, 33, 9, 24, 28, 30, 31, 15, 16, 19, 21, 23]\n",
-      "Partition 2:\n",
-      "[6, 7, 5, 11, 17]\n",
-      "Partition 3:\n",
-      "[12, 1, 3, 2, 4, 14, 8, 20, 10, 13, 18, 22]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# print the clusters.  \n",
     "for p in range(len(part_ids)):\n",
@@ -339,17 +282,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Leiden found 4 partitions\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# How many Leiden partitions were found\n",
     "part_ids_l = df_l[\"partition\"].unique()\n",
@@ -358,24 +293,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Partition 0:\n",
-      "[32, 25, 26, 29]\n",
-      "Partition 1:\n",
-      "[27, 34, 33, 9, 24, 28, 30, 31, 15, 16, 19, 21, 23]\n",
-      "Partition 2:\n",
-      "[6, 7, 5, 11, 17]\n",
-      "Partition 3:\n",
-      "[12, 1, 3, 2, 4, 14, 8, 20, 10, 13, 18, 22]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# print the clusters.  \n",
     "for p in range(len(part_ids_l)):\n",
@@ -392,7 +312,7 @@
    "metadata": {},
    "source": [
     "___\n",
-    "Copyright (c) 2019-2020, NVIDIA CORPORATION.\n",
+    "Copyright (c) 2019-2022, NVIDIA CORPORATION.\n",
     "\n",
     "Licensed under the Apache License, Version 2.0 (the \"License\");  you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n",
     "\n",
@@ -403,9 +323,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "cugraph_dev",
+   "display_name": "Python 3.8.13 ('cugraph_dev')",
    "language": "python",
-   "name": "cugraph_dev"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -417,7 +337,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.10"
+   "version": "3.8.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "cee8a395f2f0c5a5bcf513ae8b620111f4346eff6dc64e1ea99c951b2ec68604"
+   }
   }
  },
  "nbformat": 4,
diff --git a/notebooks/algorithms/community/README.md b/notebooks/algorithms/community/README.md
new file mode 100644
index 00000000000..748f27c0ffe
--- /dev/null
+++ b/notebooks/algorithms/community/README.md
@@ -0,0 +1,43 @@
+
+# cuGraph Community Notebooks
+
+<img src="../../img/zachary_graph_clusters.png" width="35%"/>
+
+## cuGraph Community notebooks contain a collection of Jupyter Notebooks with algorithms that identify related groups of nodes within the graph:
+
+* Louvain, Leiden, ECG, and Spectral Clustering all identify clusters or tightly connected vertices.
+* K-Truss is a more configurable algorithm that identifies vertices in nearly fully connected cliques.
+* Subgraph extraction pulls the new sub-graph formed given a set of vertices and returning only the edges contained between them.
+* Triangle counting gives an important metric for quantifying the overall graph connectivity by counting fully connected triples.
+
+## Summary
+
+| Algorithm          | Notebook                                                     | Description                                                  |
+| --------------- | ----------------------------------------- | ------------------------------------------------------------ |
+|        |                                                    |                                                              |
+| Louvain and Leiden                                          |[Clustering](./Community-Clustering.ipynb), [ Louvain and Leiden](./Louvain.ipynb) | Identify clusters in a graph using both the Louvain and Leiden algorithms     |
+| Ensemble Clustering for Graphs  | [Clustering](./Community-Clustering.ipynb), [ECG](./ECG.ipynb)        | Identify clusters using Louvain and consensus clustering |
+| K-Truss                                                     | [K-Truss](./ktruss.ipynb)                                | Extracts relaxed(based on parameter) cliques which include each vertex. |
+| Spectral Clustering with Balanced Cut                       | [Clustering](./Community-Clustering.ipynb),[ Spectral-Clustering](./Spectral-Clustering.ipynb)   | Identify clusters using eigenvalues and the graph Laplacian    |
+| Spectral Clustering with Modularity Maximization            | [Clustering](./Community-Clustering.ipynb),[ Spectral-Clustering](./Spectral-Clustering.ipynb)   | Identify clusters using eigenvalues and the graph Laplacian  |
+| Subgraph Extraction                                         | [Subgraph Extraction](./Subgraph-Extraction.ipynb)   | Create a subgraph of the existing graph including only the specified vertices |
+| Triangle Counting                                           | [Triangle Counting](./Triangle-Counting.ipynb)       | Count the number of size three cliques in a graph                      |
+
+[System Requirements](../../README.md#requirements)
+
+| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware |
+| --------------|------------|------------------|-----------------|----------------|
+| Brad Rees     | 04/19/2021 | created          | 0.19            | GV100, CUDA 11.0
+| Don Acosta    | 07/11/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5
+
+## Copyright
+
+Copyright (c) 2019-2022, NVIDIA CORPORATION.  All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");  you may not use this file except in compliance with the License.  You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0 
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the License for the specific language governing permissions and limitations under the License.
+
+![RAPIDS](../../img/rapids_logo.png)
diff --git a/notebooks/community/Spectral-Clustering.ipynb b/notebooks/algorithms/community/Spectral-Clustering.ipynb
similarity index 92%
rename from notebooks/community/Spectral-Clustering.ipynb
rename to notebooks/algorithms/community/Spectral-Clustering.ipynb
index 6eb0c54d10b..a314861090c 100755
--- a/notebooks/community/Spectral-Clustering.ipynb
+++ b/notebooks/algorithms/community/Spectral-Clustering.ipynb
@@ -9,16 +9,11 @@
     "In this notebook, we will use cuGraph to identify the cluster in a test graph using Spectral Clustering with both the (A) Balance Cut metric, and (B) the Modularity Maximization metric\n",
     "\n",
     "\n",
-    "Notebook Credits\n",
-    "* Original Authors: Bradley Rees and James Wyles\n",
-    "* Created:   08/01/2019\n",
-    "* Last Edit: 08/16/2020\n",
-    "\n",
-    "RAPIDS Versions: 0.14\n",
-    "\n",
-    "Test Hardware\n",
-    "* GV100 32G, CUDA 10.2\n",
-    "\n"
+    "| Author Credit              |    Date    |  Update          | cuGraph Version |  Test Hardware              |\n",
+    "| ---------------------------|------------|------------------|-----------------|-----------------------------|\n",
+    "| Brad Rees and James Wyles  | 08/01/2019 | created          | 0.14            | GV100 32G, CUDA 10.2        |\n",
+    "|                            | 08/16/2020 | updated          | 0.15   | GV100 32G, CUDA 10.2        |\n",
+    "| Don Acosta                 | 07/11/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5    |"
    ]
   },
   {
@@ -119,7 +114,7 @@
    "metadata": {},
    "source": [
     "#### Some notes about vertex IDs...\n",
-    "* The current version of cuGraph requires that vertex IDs be representable as 32-bit integers, meaning graphs currently can contain at most 2^32 unique vertex IDs. However, this limitation is being actively addressed and a version of cuGraph that accommodates more than 2^32 vertices will be available in the near future.\n",
+    "\n",
     "* cuGraph will automatically renumber graphs to an internal format consisting of a contiguous series of integers starting from 0, and convert back to the original IDs when returning data to the caller. If the vertex IDs of the data are already a contiguous series of integers starting from 0, the auto-renumbering step can be skipped for faster graph creation times.\n",
     "  * To skip auto-renumbering, set the `renumber` boolean arg to `False` when calling the appropriate graph creation API (eg. `G.from_cudf_edgelist(gdf_r, source='src', destination='dst', renumber=False)`).\n",
     "  * For more advanced renumbering support, see the examples in `structure/renumber.ipynb` and `structure/renumber-2.ipynb`\n"
@@ -135,7 +130,7 @@
     "Anthropological Research 33, 452-473 (1977).*\n",
     "\n",
     "\n",
-    "![Karate Club](../img/zachary_black_lines.png)\n",
+    "<img src=\"../../img/zachary_graph_clusters.png\" width=\"35%\"/>\n",
     "\n",
     "Because the test data has vertex IDs starting at 1, the auto-renumber feature of cuGraph (mentioned above) will be used so the starting vertex ID is zero for maximum efficiency. The resulting data will then be auto-unrenumbered, making the entire renumbering process transparent to users.\n",
     "\n",
@@ -169,7 +164,7 @@
    "outputs": [],
    "source": [
     "# Test file  \n",
-    "datafile='../data/karate-data.csv'\n",
+    "datafile='../../data/karate-data.csv'\n",
     "\n",
     "gdf = cudf.read_csv(datafile, delimiter='\\t', names=['src', 'dst'], dtype=['int32', 'int32'] )"
    ]
@@ -384,7 +379,7 @@
    "metadata": {},
    "source": [
     "___\n",
-    "Copyright (c) 2019-2020, NVIDIA CORPORATION.\n",
+    "Copyright (c) 2019-2022, NVIDIA CORPORATION.\n",
     "\n",
     "Licensed under the Apache License, Version 2.0 (the \"License\");  you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n",
     "\n",
@@ -395,9 +390,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "cugraph_dev",
+   "display_name": "Python 3.8.13 ('cugraph_dev')",
    "language": "python",
-   "name": "cugraph_dev"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -409,7 +404,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.6"
+   "version": "3.8.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "cee8a395f2f0c5a5bcf513ae8b620111f4346eff6dc64e1ea99c951b2ec68604"
+   }
   }
  },
  "nbformat": 4,
diff --git a/notebooks/community/Subgraph-Extraction.ipynb b/notebooks/algorithms/community/Subgraph-Extraction.ipynb
similarity index 88%
rename from notebooks/community/Subgraph-Extraction.ipynb
rename to notebooks/algorithms/community/Subgraph-Extraction.ipynb
index cac52262d4d..88577d756ba 100755
--- a/notebooks/community/Subgraph-Extraction.ipynb
+++ b/notebooks/algorithms/community/Subgraph-Extraction.ipynb
@@ -9,15 +9,11 @@
     "\n",
     "In this notebook, we will use cuGraph to extract a subgraph from the test graph.  \n",
     "\n",
-    "Notebook Credits\n",
-    "* Original Authors: Bradley Rees\n",
-    "* Created:   10/16/2019\n",
-    "* Last Edit: 08/16/2020\n",
-    "\n",
-    "RAPIDS Versions: 0.13\n",
-    "\n",
-    "Test Hardware\n",
-    "* GV100 32G, CUDA 10.2\n"
+    "| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware              |\n",
+    "| --------------|------------|------------------|-----------------|-----------------------------|\n",
+    "| Brad Rees     | 10/16/2019 | created          | 0.13            | GV100 32G, CUDA 10.2        |\n",
+    "|               | 08/16/2020 | updated          | 0.15   | GV100 32G, CUDA 10.2        |\n",
+    "| Don Acosta    | 07/11/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5    |"
    ]
   },
   {
@@ -45,20 +41,12 @@
     "\n"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Notice\n",
-    "Subgraph Extraction is currently not fully functional.  There are two outstanding issues to address the problems"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### Some notes about vertex IDs...\n",
-    "* The current version of cuGraph requires that vertex IDs be representable as 32-bit integers, meaning graphs currently can contain at most 2^32 unique vertex IDs. However, this limitation is being actively addressed and a version of cuGraph that accommodates more than 2^32 vertices will be available in the near future.\n",
+    "\n",
     "* cuGraph will automatically renumber graphs to an internal format consisting of a contiguous series of integers starting from 0, and convert back to the original IDs when returning data to the caller. If the vertex IDs of the data are already a contiguous series of integers starting from 0, the auto-renumbering step can be skipped for faster graph creation times.\n",
     "  * To skip auto-renumbering, set the `renumber` boolean arg to `False` when calling the appropriate graph creation API (eg. `G.from_cudf_edgelist(gdf_r, source='src', destination='dst', renumber=False)`).\n",
     "  * For more advanced renumbering support, see the examples in `structure/renumber.ipynb` and `structure/renumber-2.ipynb`\n"
@@ -73,8 +61,7 @@
     "*W. W. Zachary, An information flow model for conflict and fission in small groups, Journal of\n",
     "Anthropological Research 33, 452-473 (1977).*\n",
     "\n",
-    "\n",
-    "![Karate Club](../img/zachary_black_lines.png)\n"
+    "<img src=\"../../img/zachary_graph_clusters.png\" width=\"35%\"/>\n"
    ]
   },
   {
@@ -109,7 +96,7 @@
    "outputs": [],
    "source": [
     "# Test file    \n",
-    "datafile='../data//karate-data.csv'"
+    "datafile='../../data//karate-data.csv'"
    ]
   },
   {
@@ -277,7 +264,7 @@
    "metadata": {},
    "source": [
     "___\n",
-    "Copyright (c) 2019-2020, NVIDIA CORPORATION.\n",
+    "Copyright (c) 2019-2022, NVIDIA CORPORATION.\n",
     "\n",
     "Licensed under the Apache License, Version 2.0 (the \"License\");  you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n",
     "\n",
@@ -288,9 +275,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "cugraph_dev",
+   "display_name": "Python 3.8.13 ('cugraph_dev')",
    "language": "python",
-   "name": "cugraph_dev"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -302,7 +289,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.6"
+   "version": "3.8.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "cee8a395f2f0c5a5bcf513ae8b620111f4346eff6dc64e1ea99c951b2ec68604"
+   }
   }
  },
  "nbformat": 4,
diff --git a/notebooks/community/Triangle-Counting.ipynb b/notebooks/algorithms/community/Triangle-Counting.ipynb
similarity index 66%
rename from notebooks/community/Triangle-Counting.ipynb
rename to notebooks/algorithms/community/Triangle-Counting.ipynb
index 739943bc334..74006ae9cda 100755
--- a/notebooks/community/Triangle-Counting.ipynb
+++ b/notebooks/algorithms/community/Triangle-Counting.ipynb
@@ -6,27 +6,22 @@
    "source": [
     "# Triangle Counting\n",
     "\n",
-    "In this notebook, we will count the numner of trianges in our test dataset.  The NetworkX and cuGraph processes will be interleaved so that each step can be compared.\n",
+    "In this notebook, we will count the number of trianges in our test dataset.  The NetworkX and cuGraph processes will be interleaved so that each step can be compared.\n",
     "\n",
-    "Notebook Credits\n",
-    "* Original Authors: Bradley Rees\n",
-    "* Created:   08/01/2019\n",
-    "* Last Edit: 08/16/2020\n",
-    "\n",
-    "RAPIDS Versions: 0.13\n",
-    "\n",
-    "Test Hardware\n",
-    "\n",
-    "* GV100 32G, CUDA 10.2\n",
     "\n",
+    "| Author Credit     |    Date    |  Update          | cuGraph Version |  Test Hardware              |\n",
+    "| ------------------|------------|------------------|-----------------|-----------------------------|\n",
+    "| Brad Rees         | 08/01/2019 | created          | 0.13            | GV100 32G, CUDA 10.2        |\n",
+    "|                   | 08/16/2020 | updated          | 0.15   | GV100 32G, CUDA 10.2        |\n",
+    "| Don Acosta        | 07/11/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5    |\n",
     "\n",
     "## Introduction\n",
     "Triangle Counting, as the name implies, finds the number of triangles in a graph.  Triangles are important in computing the clustering Coefficient and can be used for clustering.  \n",
     "\n",
     "\n",
-    "To compute the Pagerank scores for a graph in cuGraph we use:<br>\n",
+    "To compute the Triangle count in cuGraph use: <br>\n",
+    "   __df = cugraph.triangle_count(G)__\n",
     "\n",
-    "**cugraph.triangles(G)**\n",
     "* __G__: cugraph.Graph object\n",
     "\n",
     "\n",
@@ -40,9 +35,14 @@
     "\n",
     "    Returns\n",
     "    -------\n",
-    "    count : int64\n",
-    "        A 64 bit integer whose value gives the number of triangles in the\n",
-    "        graph.\n",
+    "    result : cudf.DataFrame\n",
+    "        GPU data frame containing 2 cudf.Series\n",
+    "\n",
+    "        result['vertex']: cudf.Series\n",
+    "            Contains the triangle counting vertices\n",
+    "            \n",
+    "        result['counts']: cudf.Series\n",
+    "            Contains the triangle counting counts for that vertex\n",
     "\n",
     "__Reference__:\n",
     "    O. Green, P. Yalamanchili, L.M. Munguia,\n",
@@ -55,7 +55,7 @@
    "metadata": {},
    "source": [
     "#### Some notes about vertex IDs...\n",
-    "* The current version of cuGraph requires that vertex IDs be representable as 32-bit integers, meaning graphs currently can contain at most 2^32 unique vertex IDs. However, this limitation is being actively addressed and a version of cuGraph that accommodates more than 2^32 vertices will be available in the near future.\n",
+    "\n",
     "* cuGraph will automatically renumber graphs to an internal format consisting of a contiguous series of integers starting from 0, and convert back to the original IDs when returning data to the caller. If the vertex IDs of the data are already a contiguous series of integers starting from 0, the auto-renumbering step can be skipped for faster graph creation times.\n",
     "  * To skip auto-renumbering, set the `renumber` boolean arg to `False` when calling the appropriate graph creation API (eg. `G.from_cudf_edgelist(gdf_r, source='src', destination='dst', renumber=False)`).\n",
     "  * For more advanced renumbering support, see the examples in `structure/renumber.ipynb` and `structure/renumber-2.ipynb`\n"
@@ -71,7 +71,7 @@
     "Anthropological Research 33, 452-473 (1977).*\n",
     "\n",
     "\n",
-    "![Karate Club](../img/zachary_black_lines.png)\n"
+    "<img src=\"../../img/zachary_black_lines.png\" width=\"35%\"/>"
    ]
   },
   {
@@ -90,6 +90,7 @@
     "# Import needed libraries\n",
     "import cugraph\n",
     "import cudf\n",
+    "from cugraph.experimental import triangle_count as experimental_triangles\n",
     "from collections import OrderedDict"
    ]
   },
@@ -101,6 +102,7 @@
    "source": [
     "# NetworkX libraries\n",
     "import networkx as nx\n",
+    "import pandas as pd\n",
     "from scipy.io import mmread"
    ]
   },
@@ -118,7 +120,7 @@
    "outputs": [],
    "source": [
     "# Define the path to the test data  \n",
-    "datafile='../data/karate-data.csv'"
+    "datafile='../../data/karate.csv'"
    ]
   },
   {
@@ -137,7 +139,20 @@
    "source": [
     "# Read the data, this also created a NetworkX Graph \n",
     "file = open(datafile, 'rb')\n",
-    "Gnx = nx.read_edgelist(file)"
+    "df = pd.read_csv(\n",
+    "                file,\n",
+    "                delimiter=\" \",\n",
+    "                header=None,\n",
+    "                names=[\"0\", \"1\", \"weight\"],\n",
+    "                dtype={\"0\": \"int32\", \"1\": \"int32\", \"weight\": \"float32\"})\n",
+    "#Gnx = nx.read_edgelist(file)\n",
+    "Gnx = nx.from_pandas_edgelist(\n",
+    "        df,\n",
+    "        create_using=(nx.Graph()),\n",
+    "        source=\"0\",\n",
+    "        target=\"1\",\n",
+    "        edge_attr=\"weight\",\n",
+    "    )\n"
    ]
   },
   {
@@ -203,7 +218,7 @@
     "### Read in the data - GPU\n",
     "cuGraph depends on cuDF for data loading and the initial Dataframe creation\n",
     "\n",
-    "The data file contains an edge list, which represents the connection of a vertex to another.  The `source` to `destination` pairs is in what is known as Coordinate Format (COO).  In this test case, the data is just two columns.  However a third, `weight`, column is also possible"
+    "The data file contains an edge list, which represents the connection of a vertex to another.  The `source` to `destination` pairs is in what is known as Coordinate Format (COO). A third, `weight`, column is also used in this example."
    ]
   },
   {
@@ -213,9 +228,19 @@
    "outputs": [],
    "source": [
     "# Test file    \n",
-    "gdf = cudf.read_csv(datafile, delimiter='\\t', names=['src', 'dst'], dtype=['int32', 'int32'] )"
+    "gdf = cudf.read_csv(\n",
+    "                datafile,\n",
+    "                delimiter=\" \",\n",
+    "                header=None,\n",
+    "                names=[\"0\", \"1\", \"weight\"],\n",
+    "                dtype={\"0\": \"int32\", \"1\": \"int32\", \"weight\": \"float32\"})"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -231,7 +256,7 @@
    "source": [
     "# create a Graph using the source (src) and destination (dst) vertex pairs from the Dataframe \n",
     "G = cugraph.Graph()\n",
-    "G.from_cudf_edgelist(gdf, source='src', destination='dst')"
+    "G.from_cudf_edgelist(gdf, source=\"0\", destination=\"1\",edge_attr=\"weight\")"
    ]
   },
   {
@@ -247,8 +272,26 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Call cugraph.pagerank to get the pagerank scores\n",
-    "cu_count = cugraph.triangles(G)"
+    "# Call cugraph triangles to get the triangles that each vertex is included in.\n",
+    "triangles_per_vertex = experimental_triangles(G)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "triangles_per_vertex.sort_values(\n",
+    "                \"vertex\").reset_index(drop=True).rename(columns={\n",
+    "                    \"counts\": \"exp_cugraph_counts\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now combine them to get a count for comparison with the nx calculation"
    ]
   },
   {
@@ -257,7 +300,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "cu_count"
+    "cugraph_exp_triangle_results = \\\n",
+    "                triangles_per_vertex[\"counts\"].sum()\n",
+    "cugraph_exp_triangle_results\n"
    ]
   },
   {
@@ -274,7 +319,7 @@
    "metadata": {},
    "source": [
     "___\n",
-    "Copyright (c) 2019-2020, NVIDIA CORPORATION.\n",
+    "Copyright (c) 2019-2022, NVIDIA CORPORATION.\n",
     "\n",
     "Licensed under the Apache License, Version 2.0 (the \"License\");  you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n",
     "\n",
@@ -285,9 +330,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "cugraph_dev",
+   "display_name": "Python 3.8.13 ('cugraph_dev')",
    "language": "python",
-   "name": "cugraph_dev"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -299,7 +344,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.6"
+   "version": "3.8.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "cee8a395f2f0c5a5bcf513ae8b620111f4346eff6dc64e1ea99c951b2ec68604"
+   }
   }
  },
  "nbformat": 4,
diff --git a/notebooks/community/ktruss.ipynb b/notebooks/algorithms/community/ktruss.ipynb
similarity index 88%
rename from notebooks/community/ktruss.ipynb
rename to notebooks/algorithms/community/ktruss.ipynb
index 3f283558f27..20c14d76986 100644
--- a/notebooks/community/ktruss.ipynb
+++ b/notebooks/algorithms/community/ktruss.ipynb
@@ -5,21 +5,18 @@
    "metadata": {},
    "source": [
     "# K-Truss\n",
-    "# Does not run on CUDA 11.4\n",
-    "\n",
     "\n",
     "In this notebook, we will use cuGraph to identify the K-Truss clusters in a test graph  \n",
     "\n",
-    "Notebook Credits\n",
-    "* Original Authors: Bradley Rees\n",
-    "* Created:   10/28/2019\n",
-    "* Last Edit: 08/13/2021\n",
-    "\n",
-    "\n",
+    "| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware        |\n",
+    "| --------------|------------|------------------|-----------------|-----------------------|\n",
+    "| Brad Rees     | 10/28/2019 | created          | 0.6             |                       |\n",
+    "|               | 08/16/2020 | updated          | 0.15            | GV100, CUDA 10.2      |\n",
+    "|               | 08/05/2021 | tested/updated   | 21.10 nightly   | RTX 3090 CUDA 11.4    |\n",
+    "| Don Acosta    | 07/08/2022 | tested/updated   | 22.08 nightly   | DGX Tesla V100 CUDA 11.5   |\n",
     "## Introduction\n",
     "\n",
     "Compute the k-truss of the graph G.  A K-Truss is a relaxed cliques where every vertex is supported by at least k-2 triangle.\n",
-    "NOTE: k-truss is currently not supported on CUDA 11.4 systems.\n",
     "\n",
     "Ref:\n",
     "\n",
@@ -65,7 +62,7 @@
    "metadata": {},
    "source": [
     "### Some notes about vertex IDs...\n",
-    "* The current version of cuGraph requires that vertex IDs be representable as 32-bit integers, meaning graphs currently can contain at most 2^32 unique vertex IDs. However, this limitation is being actively addressed and a version of cuGraph that accommodates more than 2^32 vertices will be available in the near future.\n",
+    "\n",
     "* cuGraph will automatically renumber graphs to an internal format consisting of a contiguous series of integers starting from 0, and convert back to the original IDs when returning data to the caller. If the vertex IDs of the data are already a contiguous series of integers starting from 0, the auto-renumbering step can be skipped for faster graph creation times.\n",
     "  * To skip auto-renumbering, set the `renumber` boolean arg to `False` when calling the appropriate graph creation API (eg. `G.from_cudf_edgelist(gdf_r, source='src', destination='dst', renumber=False)`).\n",
     "  * For more advanced renumbering support, see the examples in `structure/renumber.ipynb` and `structure/renumber-2.ipynb`\n"
@@ -81,7 +78,7 @@
     "Anthropological Research 33, 452-473 (1977).*\n",
     "\n",
     "\n",
-    "![Karate Club](../img/zachary_black_lines.png)\n"
+    "<img src=\"../../img/zachary_black_lines.png\" width=\"35%\"/>\n"
    ]
   },
   {
@@ -116,7 +113,7 @@
    "outputs": [],
    "source": [
     "# Test file    \n",
-    "datafile='../data//karate-data.csv'"
+    "datafile='../../data//karate-data.csv'"
    ]
   },
   {
@@ -252,7 +249,7 @@
    "metadata": {},
    "source": [
     "___\n",
-    "Copyright (c) 2019-2020, NVIDIA CORPORATION.\n",
+    "Copyright (c) 2019-2022, NVIDIA CORPORATION.\n",
     "\n",
     "Licensed under the Apache License, Version 2.0 (the \"License\");  you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n",
     "\n",
@@ -263,9 +260,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "cugraph_dev",
+   "display_name": "Python 3.8.13 ('cugraph_dev')",
    "language": "python",
-   "name": "cugraph_dev"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -277,7 +274,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.6"
+   "version": "3.8.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "cee8a395f2f0c5a5bcf513ae8b620111f4346eff6dc64e1ea99c951b2ec68604"
+   }
   }
  },
  "nbformat": 4,
diff --git a/notebooks/img/zachary_graph_clusters.png b/notebooks/img/zachary_graph_clusters.png
new file mode 100644
index 00000000000..e9cc5de04de
Binary files /dev/null and b/notebooks/img/zachary_graph_clusters.png differ
diff --git a/notebooks/img/zachary_graph_comm.png b/notebooks/img/zachary_graph_comm.png
new file mode 100644
index 00000000000..7603cabb00c
Binary files /dev/null and b/notebooks/img/zachary_graph_comm.png differ