diff --git a/notebooks/ivf_flat_example.ipynb b/notebooks/ivf_flat_example.ipynb
index 35f63f901d..737a367bc8 100644
--- a/notebooks/ivf_flat_example.ipynb
+++ b/notebooks/ivf_flat_example.ipynb
@@ -5,7 +5,7 @@
    "id": "4f49c5c4-1170-42a7-9d6a-b90acd00c3c3",
    "metadata": {},
    "source": [
-    "# RAFT IVF Flat"
+    "# RAFT IVF Flat Example Notebook"
    ]
   },
   {
@@ -15,12 +15,12 @@
    "source": [
     "## Introduction\n",
     "\n",
-    "This notebook demonstrates how to run approximate nearest neighbor search using the IVF-Flat algorithm."
+    "This notebook demonstrates how to run approximate nearest neighbor search using RAFT IVF-Flat algorithm."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 1,
    "id": "fe73ada7-7b7f-4005-9440-85428194311b",
    "metadata": {},
    "outputs": [],
@@ -31,7 +31,18 @@
     "from pylibraft.common import DeviceResources\n",
     "from pylibraft.neighbors import ivf_flat\n",
     "import time\n",
-    "import matplotlib.pyplot as plt"
+    "import matplotlib.pyplot as plt\n",
+    "import h5py\n",
+    "import tempfile\n",
+    "import urllib.request"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "da9e8615-ea9f-4735-b70f-15ccab36c0d9",
+   "metadata": {},
+   "source": [
+    "For best performance it is recommended to use an RMM pooling allocator, to minimize the overheads of repeated CUDA allocations."
    ]
   },
   {
@@ -51,14 +62,49 @@
     "cp.cuda.set_allocator(rmm_cupy_allocator)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "b0d935f2-ba24-44fc-bdfe-a769b7fcd8e6",
+   "metadata": {},
+   "source": [
+    "The following GPU is used for this notebook"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "a5daa4b4-96de-4e74-bfd6-505b13595f62",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mon Sep 18 03:01:31 2023       \n",
+      "+---------------------------------------------------------------------------------------+\n",
+      "| NVIDIA-SMI 535.104.05             Driver Version: 535.104.05   CUDA Version: 12.2     |\n",
+      "|-----------------------------------------+----------------------+----------------------+\n",
+      "| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
+      "| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |\n",
+      "|                                         |                      |               MIG M. |\n",
+      "|=========================================+======================+======================|\n",
+      "|   0  NVIDIA A10                     On  | 00000000:81:00.0 Off |                    0 |\n",
+      "|  0%   37C    P0              56W / 150W |   1264MiB / 23028MiB |      0%      Default |\n",
+      "|                                         |                      |                  N/A |\n",
+      "+-----------------------------------------+----------------------+----------------------+\n",
+      "                                                                                         \n",
+      "+---------------------------------------------------------------------------------------+\n",
+      "| Processes:                                                                            |\n",
+      "|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |\n",
+      "|        ID   ID                                                             Usage      |\n",
+      "|=======================================================================================|\n",
+      "|    0   N/A  N/A     12573      C   /opt/conda/envs/rapids/bin/python          1252MiB |\n",
+      "+---------------------------------------------------------------------------------------+\n"
+     ]
+    }
+   ],
    "source": [
-    "# Report the GPU in us\n",
+    "# Report the GPU in use\n",
     "!nvidia-smi"
    ]
   },
@@ -72,30 +118,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 4,
    "id": "496fc8a6-139f-4b88-a2f4-a34357fd1712",
    "metadata": {},
    "outputs": [],
    "source": [
-    "def memmap_bin_file(bin_file, dtype, shape=None):\n",
-    "    if bin_file is None:\n",
-    "        return None\n",
-    "    a = np.memmap(bin_file, mode=\"r\", dtype=\"uint32\", shape=(2,))\n",
-    "    if shape is None:\n",
-    "        shape = (a[0], a[1])\n",
-    "    # print('# {}: shape: {}, dtype: {}'.format(bin_file, shape, dtype))\n",
-    "    return np.memmap(bin_file, mode=\"r\", dtype=dtype, offset=8, shape=shape)\n",
-    "\n",
-    "\n",
     "def calc_recall(ann_idx, true_nn_idx):\n",
-    "    ann_idx = np.asarray(ann_idx)\n",
-    "    if ann_idx.shape != true_nn_idx.shape:\n",
+    "    k = ann_idx.shape[1]\n",
+    "    if k > true_nn_idx.shape[1]:\n",
     "        raise RuntimeError(\n",
     "            \"Incompatible shapes {} vs {}\".format(ann_idx.shape, true_nn_idx.shape)\n",
     "        )\n",
+    "    \n",
     "    n = 0\n",
     "    for i in range(ann_idx.shape[0]):\n",
-    "        n += np.intersect1d(ann_idx[i, :], true_nn_idx[i, :]).size\n",
+    "        n += cp.intersect1d(ann_idx[i, :], true_nn_idx[i, :k]).size\n",
     "    recall = n / ann_idx.size\n",
     "    return recall\n",
     "\n",
@@ -108,7 +145,7 @@
     "            ... do something ...\n",
     "        print(np.min(timer.timings))\n",
     "\n",
-    "        This class is part of the rapids/cuml benchmark suite\n",
+    "        This class is borrowed from the rapids/cuml benchmark suite\n",
     "    \"\"\"\n",
     "\n",
     "    def __init__(self, reps=1, warmup=0):\n",
@@ -128,76 +165,77 @@
   },
   {
    "cell_type": "markdown",
-   "id": "eee226b2-7110-42da-b022-385ee7462ed0",
-   "metadata": {},
-   "source": [
-    "## Load dataset"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "ba75cbad-1bf0-4c07-b130-c34d4e51410f",
+   "id": "88a654cc-6389-4526-a3e6-826de5606a09",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "# TODO use a smaller dataset and dataset loader\n",
-    "k = 10\n",
-    "\n",
-    "dtype=np.float32\n",
-    "\n",
-    "dataset_dirname = \"/workspace/rapids/gh/data/deep-1B\"\n",
-    "\n",
-    "dataset_filename = os.path.join(dataset_dirname, \"base.10M.fbin\")\n",
-    "queries_filename = os.path.join(dataset_dirname, \"query.public.10K.fbin\")\n",
+    "## Load dataset\n",
     "\n",
-    "# groundthruth filenames\n",
-    "dataset_dirname = \"/workspace/rapids/gh/data/deep-10M\"\n",
-    "gt_indices_filename = os.path.join(dataset_dirname, \"groundtruth.neighbors.ibin\")\n",
-    "gt_dist_filename = os.path.join(dataset_dirname, \"groundtruth.distances.fbin\")\n",
+    "The ANN benchmarks website provides the datasets in HDF5 format.\n",
     "\n",
-    "dataset_np = memmap_bin_file(dataset_filename, dtype)\n",
-    "dataset = cp.asarray(dataset_np)\n",
-    "\n",
-    "n_samples = dataset.shape[0]\n",
-    "n_features = dataset.shape[1]\n",
-    "\n",
-    "queries = np.asarray(memmap_bin_file(queries_filename, dtype))\n",
-    "\n",
-    "gt_indices_100 = memmap_bin_file(gt_indices_filename, dtype=np.int32)\n",
-    "gt_distances_100 = memmap_bin_file(gt_dist_filename, dtype=np.float32)"
+    "The list of prepared datasets can be found at https://github.com/erikbern/ann-benchmarks/#data-sets"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
-   "id": "61a4c327-800a-4b8d-a978-37ec80d4dfad",
+   "id": "5f529ad6-b0bd-495c-bf7c-43f10fb6aa14",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Dataset shape=(10000000,96), dtype=<class 'numpy.float32'>, size=   3.6 GiB\n"
+      "The index and data will be saved in /tmp/raft_ivf_flat_example\n"
      ]
     }
    ],
    "source": [
-    "itemsize = np.dtype(dtype).itemsize \n",
-    "total_size = n_samples * n_features * itemsize / (1<<30)\n",
-    "print(\"Dataset shape=({0},{1}), dtype={2}, size={3:6.1f} GiB\".format(n_samples, n_features, dtype, total_size))"
+    "#DATASET_URL = \"http://ann-benchmarks.com/glove-100-angular.hdf5\"\n",
+    "DATASET_URL = \"http://ann-benchmarks.com/sift-128-euclidean.hdf5\"\n",
+    "DATASET_FILENAME = DATASET_URL.split('/')[-1]\n",
+    "\n",
+    "# We'll need to load store some data in this tutorial\n",
+    "WORK_FOLDER = os.path.join(tempfile.gettempdir(), 'raft_ivf_flat_example')\n",
+    "\n",
+    "if not os.path.exists(WORK_FOLDER):\n",
+    "   os.makedirs(WORK_FOLDER)\n",
+    "print(\"The index and data will be saved in\", WORK_FOLDER)\n",
+    "\n",
+    "## download the dataset\n",
+    "dataset_path = os.path.join(WORK_FOLDER, DATASET_FILENAME)\n",
+    "if not os.path.exists(dataset_path):\n",
+    "    urllib.request.urlretrieve(DATASET_URL, dataset_path)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
-   "id": "84ca624a-9ced-4083-9bdd-9438cfff16f4",
+   "id": "3d68a7db-bcf4-449c-96c3-1e8ab146c84d",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loaded dataset of size (1000000, 128),  0.5 GiB; metric: 'euclidean'.\n",
+      "Number of test queries: 10000\n"
+     ]
+    }
+   ],
    "source": [
-    "# we need only k columns from the groundthruth files\n",
-    "gt_indices = np.asarray(gt_indices_100[:, :k])\n",
-    "gt_distances = np.asarray(gt_distances_100[:, :k])"
+    "f = h5py.File(dataset_path, \"r\")\n",
+    "\n",
+    "metric = f.attrs['distance']\n",
+    "\n",
+    "dataset = cp.array(f['train'])\n",
+    "queries = cp.array(f['test'])\n",
+    "gt_neighbors = cp.array(f['neighbors'])\n",
+    "gt_distances = cp.array(f['distances'])\n",
+    "\n",
+    "itemsize = dataset.dtype.itemsize \n",
+    "\n",
+    "print(f\"Loaded dataset of size {dataset.shape}, {dataset.size*itemsize/(1<<30):4.1f} GiB; metric: '{metric}'.\")\n",
+    "print(f\"Number of test queries: {queries.shape[0]}\")"
    ]
   },
   {
@@ -218,25 +256,22 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 315 ms, sys: 21.9 ms, total: 337 ms\n",
-      "Wall time: 334 ms\n"
+      "CPU times: user 189 ms, sys: 32.3 ms, total: 222 ms\n",
+      "Wall time: 226 ms\n"
      ]
     }
    ],
    "source": [
     "%%time\n",
-    "#handle = Handle()\n",
-    "\n",
-    "# see documentation https://github.com/rapidsai/raft/blob/082be6ecd4437d180bf34d5ba5d691a27b21141f/python/pylibraft/pylibraft/neighbors/ivf_flat/ivf_flat.pyx#L77-L124\n",
     "build_params = ivf_flat.IndexParams(\n",
     "        n_lists=1024,\n",
-    "        metric=\"sqeuclidean\",\n",
+    "        metric=\"euclidean\",\n",
     "        kmeans_trainset_fraction=0.1,\n",
     "        kmeans_n_iters=20,\n",
     "        add_data_on_build=True\n",
     "    )\n",
     "\n",
-    "index = ivf_flat.build(build_params, dataset)#, handle=handle)"
+    "index = ivf_flat.build(build_params, dataset)"
    ]
   },
   {
@@ -249,7 +284,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 8,
    "id": "1aec7024-6e5d-4d2c-82e6-7b5734aec958",
    "metadata": {},
    "outputs": [
@@ -257,7 +292,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Index(type=IVF-FLAT, metric=sqeuclidean, size=10000000, dim=96, n_lists=1024, adaptive_centers=False)\n"
+      "Index(type=IVF-FLAT, metric=euclidean, size=1000000, dim=128, n_lists=1024, adaptive_centers=False)\n"
      ]
     }
    ],
@@ -274,24 +309,11 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "ebfc0980-32a8-480e-bdc0-7a5472bbfb6b",
+   "cell_type": "markdown",
+   "id": "89ba2eaa-4c85-4e1c-b07c-920394e55dce",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(10000, 96)"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
    "source": [
-    "queries.shape"
+    "It is recommended to reuse devece recosources accross multiple invacations of search. "
    ]
   },
   {
@@ -306,7 +328,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 11,
    "id": "595454e1-7240-4b43-9a73-963d5670b00c",
    "metadata": {},
    "outputs": [
@@ -314,17 +336,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 386 ms, sys: 209 ms, total: 594 ms\n",
-      "Wall time: 590 ms\n"
+      "CPU times: user 165 ms, sys: 141 ms, total: 306 ms\n",
+      "Wall time: 303 ms\n"
      ]
     }
    ],
    "source": [
     "%%time\n",
     "n_queries=10000\n",
-    "handle = DeviceResources()\n",
     "# n_probes is the number of clusters we select in the first (coarse) search step. This is the only hyper parameter for search.\n",
-    "search_params = ivf_flat.SearchParams(n_probes=50)\n",
+    "search_params = ivf_flat.SearchParams(n_probes=30)\n",
     "\n",
     "# Search 10 nearest neighbors.\n",
     "distances, indices = ivf_flat.search(search_params, index, cp.asarray(queries[:n_queries,:]), k=10, handle=handle)\n",
@@ -343,23 +364,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 12,
    "id": "8cd9cd20-ca00-4a35-a0a0-86636521b31a",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "0.99419"
+       "0.974"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "calc_recall(neighbors, gt_indices)"
+    "calc_recall(neighbors, gt_neighbors)"
    ]
   },
   {
@@ -367,27 +388,29 @@
    "id": "cde5079c-9777-45a1-9545-cffbcc59988f",
    "metadata": {},
    "source": [
-    "## Save and load the index"
+    "## Save and load the index\n",
+    "You can serialize the index to file, and load it later."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 13,
    "id": "bf94e45c-e7fb-4aa3-a611-ddaee7ac41ae",
    "metadata": {},
    "outputs": [],
    "source": [
-    "ivf_flat.save(\"my_ivf_flat_index.bin\", index)"
+    "index_file = os.path.join(WORK_FOLDER, \"my_ivf_flat_index.bin\")\n",
+    "ivf_flat.save(index_file, index)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 14,
    "id": "1622d9be-be41-4d25-be99-d348c5e54957",
    "metadata": {},
    "outputs": [],
    "source": [
-    "index = ivf_flat.load(\"my_ivf_flat_index.bin\")"
+    "index = ivf_flat.load(index_file)"
    ]
   },
   {
@@ -396,28 +419,14 @@
    "metadata": {},
    "source": [
     "## Tune search parameters\n",
-    "Search has a single hyper parameter: n_probes, which describes how many neighboring cluster is searched (probed) for each query. Within a probed cluster, we compute the distance between all the vectors in the cluster and the query point, and select the top-k neighbors. Finally, we consider all the neighbor candidates from the probed clusters, and select top-k out of them."
+    "Search has a single hyper parameter: `n_probes`, which describes how many neighboring cluster is searched (probed) for each query. Within a probed cluster, the distance is computed between all the vectors in the cluster and the query point, and the top-k neighbors are selected. Finally, the top-k neighobrs are selected from all the neighbor candidates from the probed clusters.\n",
+    "\n",
+    "Let's see how search accuracy and latency changes when we change the `n_probes` parameter."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
-   "id": "07b89052-c41d-464e-9cd3-cf1f1fb16b32",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Index(type=IVF-FLAT, metric=sqeuclidean, size=10000000, dim=96, n_lists=1024, adaptive_centers=False)\n"
-     ]
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 15,
    "id": "ace0c31f-af75-4352-a438-123a9a03612c",
    "metadata": {},
    "outputs": [
@@ -426,56 +435,66 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "Benchmarking search with n_probes= 10\n",
-      "recall 0.93047\n",
-      "Average search time:   0.081 +/-  0.0559 s\n",
-      "Queries per second (QPS):   123637\n",
+      "Benchmarking search with n_probes = 10\n",
+      "recall 0.86509\n",
+      "Average search time:   0.067 +/-  0.0464 s\n",
+      "Queries per second (QPS):   148962\n",
       "\n",
-      "Benchmarking search with n_probes= 50\n",
-      "recall 0.99419\n",
-      "Average search time:   0.391 +/-   0.276 s\n",
-      "Queries per second (QPS):    25587\n",
+      "Benchmarking search with n_probes = 20\n",
+      "recall 0.94818\n",
+      "Average search time:   0.133 +/-  0.0932 s\n",
+      "Queries per second (QPS):    75407\n",
       "\n",
-      "Benchmarking search with n_probes= 100\n",
-      "recall 0.99842\n",
-      "Average search time:   0.774 +/-   0.546 s\n",
-      "Queries per second (QPS):    12927\n",
+      "Benchmarking search with n_probes = 30\n",
+      "recall 0.974\n",
+      "Average search time:   0.198 +/-    0.14 s\n",
+      "Queries per second (QPS):    50476\n",
       "\n",
-      "Benchmarking search with n_probes= 200\n",
-      "recall 0.99941\n",
-      "Average search time:   1.521 +/-    1.07 s\n",
-      "Queries per second (QPS):     6575\n",
+      "Benchmarking search with n_probes = 50\n",
+      "recall 0.99152\n",
+      "Average search time:   0.328 +/-   0.232 s\n",
+      "Queries per second (QPS):    30450\n",
       "\n",
-      "Benchmarking search with n_probes= 500\n",
-      "recall 0.99956\n",
-      "Average search time:   3.756 +/-    2.66 s\n",
-      "Queries per second (QPS):     2662\n",
+      "Benchmarking search with n_probes = 100\n",
+      "recall 0.99827\n",
+      "Average search time:   0.652 +/-    0.46 s\n",
+      "Queries per second (QPS):    15330\n",
       "\n",
-      "Benchmarking search with n_probes= 1000\n",
-      "recall 0.99957\n",
-      "Average search time:   6.897 +/-    4.88 s\n",
-      "Queries per second (QPS):     1450\n"
+      "Benchmarking search with n_probes = 200\n",
+      "recall 0.99926\n",
+      "Average search time:   1.266 +/-   0.894 s\n",
+      "Queries per second (QPS):     7901\n",
+      "\n",
+      "Benchmarking search with n_probes = 500\n",
+      "recall 0.99933\n",
+      "Average search time:   2.881 +/-    2.04 s\n",
+      "Queries per second (QPS):     3471\n",
+      "\n",
+      "Benchmarking search with n_probes = 1024\n",
+      "recall 0.99933\n",
+      "Average search time:   2.258 +/-     1.6 s\n",
+      "Queries per second (QPS):     4429\n"
      ]
     }
    ],
    "source": [
-    "n_probes = np.asarray([10, 50, 100, 200, 500, 1000]);\n",
+    "n_probes = np.asarray([10, 20, 30, 50, 100, 200, 500, 1024]);\n",
     "qps = np.zeros(n_probes.shape);\n",
     "recall = np.zeros(n_probes.shape);\n",
     "\n",
     "for i in range(len(n_probes)):\n",
-    "    print(\"\\nBenchmarking search with n_probes=\", n_probes[i])\n",
+    "    print(\"\\nBenchmarking search with n_probes =\", n_probes[i])\n",
     "    timer = BenchmarkTimer(reps=1, warmup=1)\n",
     "    for rep in timer.benchmark_runs():\n",
     "        distances, neighbors = ivf_flat.search(\n",
     "            ivf_flat.SearchParams(n_probes=n_probes[i]),\n",
     "            index,\n",
     "            cp.asarray(queries),\n",
-    "            k,\n",
+    "            k=10,\n",
     "            handle=handle,\n",
     "        )\n",
     "    \n",
-    "    recall[i] = calc_recall(cp.asnumpy(neighbors), gt_indices)\n",
+    "    recall[i] = calc_recall(cp.asnumpy(neighbors), gt_neighbors)\n",
     "    print(\"recall\", recall[i])\n",
     "\n",
     "    timings = np.asarray(timer.timings)\n",
@@ -486,15 +505,23 @@
     "    print(\"Queries per second (QPS): {0:8.0f}\".format(qps[i]))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "20b2498c-7231-4211-990e-600d5c26a9a1",
+   "metadata": {},
+   "source": [
+    "The plots below illustrate how the accuracy (recall) and the throughput (queries per second) depends on the `n_probes` parameter."
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 17,
    "id": "e1ac370f-91c8-4054-95c7-a749df5f16d2",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1200x300 with 3 Axes>"
       ]
@@ -534,97 +561,213 @@
    "metadata": {},
    "source": [
     "## Adjust build parameters\n",
-    "### n_clusters"
+    "### n_lists\n",
+    "The number of clusters (or lists) is set by the n_list parameter. Let's change it to 100 clusters."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "id": "addbfff3-7773-4290-9608-5489edf4886d",
    "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0c44800f-1e9e-4f7b-87fe-0f25e6590faa",
-   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 536 ms, sys: 15.3 ms, total: 551 ms\n",
+      "Wall time: 545 ms\n"
+     ]
+    }
+   ],
    "source": [
-    "### trainset fraction"
+    "%%time\n",
+    "build_params = ivf_flat.IndexParams(\n",
+    "        n_lists=100,\n",
+    "        metric=\"euclidean\",\n",
+    "        kmeans_trainset_fraction=1,\n",
+    "        kmeans_n_iters=20,\n",
+    "        add_data_on_build=True\n",
+    "    )\n",
+    "\n",
+    "index = ivf_flat.build(build_params, dataset, handle=handle)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "f9d343c8-a295-4f31-8a3a-3ead9d26f50f",
+   "id": "48db27f9-54c8-4dac-839b-af94ada8885f",
    "metadata": {},
-   "source": []
+   "source": [
+    "The ratio of n_probes / n_list will determine how large fraction of the dataset is searched for each query. The right combination depends on the use case. Here we will search 10 of the clusters for each query."
+   ]
   },
   {
-   "cell_type": "markdown",
-   "id": "25289ebc-7d89-4fa6-bc62-e25b6e77750c",
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "8a0149ad-de38-4195-97a5-ce5d5d877036",
    "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 598 ms, sys: 392 ms, total: 990 ms\n",
+      "Wall time: 985 ms\n"
+     ]
+    }
+   ],
    "source": [
-    "### add vectors on build\n",
-    "Currently we cannot configure how RAFT sub-samples the input. If we want to have a fine control on how we select the training set, then we can create the index in two steps:\n",
-    "1. Define cluster centers on a training set, but do not add any vector to the index\n",
-    "2. add vectors to the index (extend)\n",
+    "%%time\n",
+    "n_queries=10000\n",
+    "\n",
+    "search_params = ivf_flat.SearchParams(n_probes=10)\n",
     "\n",
-    "- The second step is familiar for faiss users.\n",
-    "- Note that raft does not require adding the data in batches. We do internal batching. If the user prefers, can use your own batching.\n",
-    "- We have an option in controlling whether the cluster centers should be recalculated.\n"
+    "# Search 10 nearest neighbors.\n",
+    "distances, indices = ivf_flat.search(search_params, index, cp.asarray(queries[:n_queries,:]), k=10, handle=handle)\n",
+    "    \n",
+    "handle.sync()\n",
+    "distances, neighbors = cp.asnumpy(distances), cp.asnumpy(indices)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
-   "id": "7ebcf970-94ed-4825-9885-277bd984b90c",
+   "execution_count": 20,
+   "id": "eedc3ec4-06af-42c5-8cdf-490a5c2bc49a",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "Index(type=IVF-FLAT, metric=sqeuclidean, size=10000000, dim=96, n_lists=1024, adaptive_centers=False)"
+       "0.9884"
       ]
      },
-     "execution_count": 54,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "build_params = ivf_flat.IndexParams(\n",
-    "        n_lists=1024,\n",
-    "        metric=\"sqeuclidean\",\n",
-    "        kmeans_trainset_fraction=1,\n",
-    "        kmeans_n_iters=20,\n",
-    "        add_data_on_build=False\n",
-    "    )\n",
-    "\n",
-    "n_train = 10000\n",
-    "train_set = dataset[cp.random.choice(dataset.shape[0], n_train, replace=False),:]\n",
-    "index = ivf_flat.build(build_params, train_set)\n",
-    "ivf_flat.extend(index, dataset, cp.arange(dataset.shape[0], dtype=cp.int64))"
+    "calc_recall(neighbors, gt_neighbors)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c44800f-1e9e-4f7b-87fe-0f25e6590faa",
+   "metadata": {},
+   "source": [
+    "### trainset_fraction\n",
+    "During clustering we can sub-sample the dataset. The parameter `trainset_fraction` determines what fraction to use. Often we get good results by using only 1/10th of the dataset for clustering. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "5a54d190-64d4-4cd4-a497-365cbffda871",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 76.6 ms, sys: 27 µs, total: 76.6 ms\n",
+      "Wall time: 76.2 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "build_params = ivf_flat.IndexParams( \n",
+    "        n_lists=100, \n",
+    "        metric=\"sqeuclidean\", \n",
+    "        kmeans_trainset_fraction=0.1, \n",
+    "        kmeans_n_iters=20 \n",
+    "    ) \n",
+    "index = ivf_flat.build(build_params, dataset, handle=handle)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d86a213-d6ae-4fca-9082-cb5a4d1dab36",
+   "metadata": {},
+   "source": [
+    "We see only a minimal change in the recall"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
-   "id": "42c70329-1a35-4d11-8688-087de8a637c1",
+   "execution_count": 22,
+   "id": "4cc992e8-a5e5-4508-b790-0e934160b660",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "10000000"
+       "0.98798"
       ]
      },
-     "execution_count": 55,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "index.size"
+    "search_params = ivf_flat.SearchParams(n_probes=10)\n",
+    "\n",
+    "distances, indices = ivf_flat.search(search_params, index, cp.asarray(queries[:n_queries,:]), k=10, handle=handle)\n",
+    "    \n",
+    "handle.sync()\n",
+    "distances, neighbors = cp.asnumpy(distances), cp.asnumpy(indices)\n",
+    "calc_recall(neighbors, gt_neighbors)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "25289ebc-7d89-4fa6-bc62-e25b6e77750c",
+   "metadata": {},
+   "source": [
+    "### Add vectors on build\n",
+    "Currently you cannot configure how RAFT sub-samples the input. If you want to have a fine control on how the training set is selected, then create the index in two steps:\n",
+    "1. Define cluster centers on a training set, but do not add any vector to the index\n",
+    "2. Add vectors to the index (extend)\n",
+    "\n",
+    "This workflow shall be familiar to FAISS users. Note that raft does not require adding the data in batches, internal batching is used when necessary.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "7ebcf970-94ed-4825-9885-277bd984b90c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Index before adding vectors Index(type=IVF-FLAT, metric=sqeuclidean, size=0, dim=128, n_lists=1024, adaptive_centers=False)\n",
+      "Index after adding vectors Index(type=IVF-FLAT, metric=sqeuclidean, size=1000000, dim=128, n_lists=1024, adaptive_centers=False)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# subsample the dataset\n",
+    "n_train = 10000\n",
+    "train_set = dataset[cp.random.choice(dataset.shape[0], n_train, replace=False),:]\n",
+    "\n",
+    "# build using training set\n",
+    "build_params = ivf_flat.IndexParams(\n",
+    "        n_lists=1024,\n",
+    "        metric=\"sqeuclidean\",\n",
+    "        kmeans_trainset_fraction=1,\n",
+    "        kmeans_n_iters=20,\n",
+    "        add_data_on_build=False\n",
+    "    )\n",
+    "index = ivf_flat.build(build_params, train_set)\n",
+    "\n",
+    "print(\"Index before adding vectors\", index)\n",
+    "\n",
+    "ivf_flat.extend(index, dataset, cp.arange(dataset.shape[0], dtype=cp.int64))\n",
+    "\n",
+    "print(\"Index after adding vectors\", index)"
    ]
   },
   {