diff --git a/scripts/demo/Speedup & HNSW Integration.ipynb b/scripts/demo/Speedup & HNSW Integration.ipynb
index 856f7d5a..c960337c 100644
--- a/scripts/demo/Speedup & HNSW Integration.ipynb	
+++ b/scripts/demo/Speedup & HNSW Integration.ipynb	
@@ -1,345 +1,509 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "c44582e7",
-   "metadata": {},
-   "source": [
-    "# Speedup & HNSW Integration Demo\n",
-    "### This notebook demonstrates:\n",
-    "### 1. Computational speedup using C++ bindings vs. pure Python\n",
-    "### 2. HNSW approximate nearest neighbor search with `hnswlib`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c8ca3890",
-   "metadata": {},
-   "source": [
-    "## Requirements: numpy, matplotlib, hnswlib, pybind11 (for C++ extension)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8e509e92",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install numpy matplotlib hnswlib ipython"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c53cd848",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import time\n",
-    "import hnswlib\n",
-    "import sys\n",
-    "from IPython.display import display, Markdown"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1f8b16ca",
-   "metadata": {},
-   "source": [
-    "## Part 1: Speedup Comparison (C++ vs Python)\n",
-    "### We implement a computationally intensive task (vector magnitude calculation) in both Python and C++.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d8827faa",
-   "metadata": {},
-   "source": [
-    "### Pure Python implementation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5ba74cc9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def magnitude_python(arr):\n",
-    "    return np.sqrt(np.sum(arr**2, axis=1))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2cd53144",
-   "metadata": {},
-   "source": [
-    "### C++ implementation using pybind11 (compile with: c++ -O3 -Wall -shared -std=c++11 -fPIC $(python3 -m pybind11 --includes) magnitude.cpp -o magnitude$(python3-config --extension-suffix))\n",
-    "### Save the following as magnitude.cpp:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d6433415",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cpp_code = \"\"\"\n",
-    "#include <cmath>\n",
-    "#include <vector>\n",
-    "#include <pybind11/pybind11.h>\n",
-    "#include <pybind11/numpy.h>\n",
-    "\n",
-    "namespace py = pybind11;\n",
-    "\n",
-    "py::array_t<double> magnitude_cpp(py::array_t<double> input) {\n",
-    "    auto buf = input.request();\n",
-    "    double* ptr = (double*) buf.ptr;\n",
-    "    size_t rows = buf.shape[0];\n",
-    "    size_t cols = buf.shape[1];\n",
-    "    \n",
-    "    std::vector<double> result(rows);\n",
-    "    \n",
-    "    for (size_t i = 0; i < rows; ++i) {\n",
-    "        double sum_sq = 0.0;\n",
-    "        for (size_t j = 0; j < cols; ++j) {\n",
-    "            double val = ptr[i * cols + j];\n",
-    "            sum_sq += val * val;\n",
-    "        }\n",
-    "        result[i] = std::sqrt(sum_sq);\n",
-    "    }\n",
-    "    \n",
-    "    return py::array(result.size(), result.data());\n",
-    "}\n",
-    "\n",
-    "PYBIND11_MODULE(magnitude, m) {\n",
-    "    m.def(\"magnitude_cpp\", &magnitude_cpp, \"Calculate vector magnitudes\");\n",
-    "}\n",
-    "\"\"\"\n",
-    "\n",
-    "# Optionally, save to file:\n",
-    "with open(\"magnitude.cpp\", \"w\") as f:\n",
-    "    f.write(cpp_code)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2232278f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Compile and load the extension\n",
-    "try:\n",
-    "    import magnitude\n",
-    "except ImportError:\n",
-    "    display(Markdown(\"**Note:** C++ extension not compiled. Using Python fallback for demo.\"))\n",
-    "    magnitude = None"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cf32d682",
-   "metadata": {},
-   "source": [
-    "## Benchmark Setup\n",
-    "### We test with increasing dataset sizes to compare performance."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0d8b69d9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def benchmark():\n",
-    "    sizes = [1000, 10000, 100000, 500000]\n",
-    "    py_times, cpp_times = [], []\n",
-    "    \n",
-    "    for size in sizes:\n",
-    "        data = np.random.rand(size, 100)  # 100D vectors\n",
-    "        \n",
-    "        # Pure Python\n",
-    "        start = time.time()\n",
-    "        _ = magnitude_python(data)\n",
-    "        py_time = time.time() - start\n",
-    "        py_times.append(py_time)\n",
-    "        \n",
-    "        # C++ (if available)\n",
-    "        cpp_time = float('inf')\n",
-    "        if magnitude:\n",
-    "            start = time.time()\n",
-    "            _ = magnitude.magnitude_cpp(data)\n",
-    "            cpp_time = time.time() - start\n",
-    "        cpp_times.append(cpp_time)\n",
-    "        \n",
-    "        print(f\"Size {size:>7}: Python={py_time:.4f}s | C++={cpp_time:.4f}s\")\n",
-    "    \n",
-    "    return sizes, py_times, cpp_times\n",
-    "\n",
-    "sizes, py_times, cpp_times = benchmark()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9c17badd",
-   "metadata": {},
-   "source": [
-    "### Speedup Visualization"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bf554022",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "plt.figure(figsize=(10, 6))\n",
-    "plt.plot(sizes, py_times, 'o-', label='Pure Python')\n",
-    "plt.plot(sizes, cpp_times, 's-', label='C++ Extension')\n",
-    "plt.xscale('log')\n",
-    "plt.yscale('log')\n",
-    "plt.xlabel('Number of Vectors')\n",
-    "plt.ylabel('Execution Time (s)')\n",
-    "plt.title('Computational Speedup: C++ vs Python')\n",
-    "plt.legend()\n",
-    "plt.grid(True, which=\"both\", ls=\"--\")\n",
-    "plt.show()\n",
-    "\n",
-    "# Calculate speedup ratios\n",
-    "speedup = [py / cpp if cpp > 0 else float('inf') for py, cpp in zip(py_times, cpp_times)]\n",
-    "display(Markdown(f\"**Max Speedup**: {max(speedup):.1f}x\"))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e133a563",
-   "metadata": {},
-   "source": [
-    "## Part 2: HNSW Integration\n",
-    "### Build an approximate nearest neighbors index with HNSW and benchmark query speed"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "723bf383",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def benchmark_hnsw(dim=128, num_elements=100000, num_queries=1000):\n",
-    "    # Generate sample data\n",
-    "    data = np.float32(np.random.random((num_elements, dim)))\n",
-    "    queries = np.float32(np.random.random((num_queries, dim)))\n",
-    "    \n",
-    "    # Initialize HNSW index\n",
-    "    p = hnswlib.Index(space='l2', dim=dim)\n",
-    "    p.init_index(max_elements=num_elements, ef_construction=200, M=16)\n",
-    "    \n",
-    "    # Add data\n",
-    "    p.add_items(data)\n",
-    "    \n",
-    "    # Set query ef parameter\n",
-    "    p.set_ef(50)\n",
-    "    \n",
-    "    # Benchmark queries\n",
-    "    start = time.time()\n",
-    "    _ = p.knn_query(queries, k=10)\n",
-    "    query_time = time.time() - start\n",
-    "    \n",
-    "    return query_time / num_queries * 1000  # ms per query"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5912de9c",
-   "metadata": {},
-   "source": [
-    "## HNSW Query Performance\n",
-    "### Measure time per query for 10-NN search in 128D space."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "874b6cd2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "query_time_ms = benchmark_hnsw()\n",
-    "display(Markdown(f\"**HNSW Query Speed**: {query_time_ms:.4f} ms per query\"))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1af914d8",
-   "metadata": {},
-   "source": [
-    "## HNSW Scalability Test\n",
-    "### Compare query latency at different dataset sizes."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "fc3362b5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dataset_sizes = [10000, 50000, 100000, 200000]\n",
-    "query_times = []\n",
-    "\n",
-    "for size in dataset_sizes:\n",
-    "    time_ms = benchmark_hnsw(num_elements=size)\n",
-    "    query_times.append(time_ms)\n",
-    "    print(f\"Size {size:>7}: {time_ms:.4f} ms/query\")\n",
-    "\n",
-    "# Plot results\n",
-    "plt.figure(figsize=(10, 6))\n",
-    "plt.plot(dataset_sizes, query_times, 'o-')\n",
-    "plt.xlabel('Dataset Size')\n",
-    "plt.ylabel('Query Time (ms)')\n",
-    "plt.title('HNSW Scalability')\n",
-    "plt.grid(True)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0eb54800",
-   "metadata": {},
-   "source": [
-    "## Conclusion\n",
-    "### - **C++ bindings** provide **>10x speedup** for compute-heavy tasks vs pure Python.\n",
-    "### - **HNSW** delivers **sub-millisecond queries** for approximate nearest neighbors at scale."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "venv",
-   "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.12.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "c44582e7",
+      "metadata": {
+        "id": "c44582e7"
+      },
+      "source": [
+        "# Speedup & HNSW Integration Demo\n",
+        "### This notebook demonstrates:\n",
+        "### 1. Computational speedup using C++ bindings vs. pure Python\n",
+        "### 2. HNSW approximate nearest neighbor search with `hnswlib`\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "id": "8e509e92",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "8e509e92",
+        "outputId": "994c9f55-d6d1-4321-b557-20b8aa54128c"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (2.0.2)\n",
+            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (3.10.0)\n",
+            "Collecting hnswlib\n",
+            "  Downloading hnswlib-0.8.0.tar.gz (36 kB)\n",
+            "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+            "Requirement already satisfied: ipython in /usr/local/lib/python3.12/dist-packages (7.34.0)\n",
+            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.3.3)\n",
+            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (0.12.1)\n",
+            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (4.63.0)\n",
+            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.5.0)\n",
+            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (26.2)\n",
+            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (11.3.0)\n",
+            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (3.3.2)\n",
+            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (2.9.0.post0)\n",
+            "Requirement already satisfied: setuptools>=18.5 in /usr/local/lib/python3.12/dist-packages (from ipython) (75.2.0)\n",
+            "Collecting jedi>=0.16 (from ipython)\n",
+            "  Downloading jedi-0.20.0-py2.py3-none-any.whl.metadata (23 kB)\n",
+            "Requirement already satisfied: decorator in /usr/local/lib/python3.12/dist-packages (from ipython) (4.4.2)\n",
+            "Requirement already satisfied: pickleshare in /usr/local/lib/python3.12/dist-packages (from ipython) (0.7.5)\n",
+            "Requirement already satisfied: traitlets>=4.2 in /usr/local/lib/python3.12/dist-packages (from ipython) (5.7.1)\n",
+            "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /usr/local/lib/python3.12/dist-packages (from ipython) (3.0.52)\n",
+            "Requirement already satisfied: pygments in /usr/local/lib/python3.12/dist-packages (from ipython) (2.20.0)\n",
+            "Requirement already satisfied: backcall in /usr/local/lib/python3.12/dist-packages (from ipython) (0.2.0)\n",
+            "Requirement already satisfied: matplotlib-inline in /usr/local/lib/python3.12/dist-packages (from ipython) (0.2.2)\n",
+            "Requirement already satisfied: pexpect>4.3 in /usr/local/lib/python3.12/dist-packages (from ipython) (4.9.0)\n",
+            "Requirement already satisfied: parso<0.9.0,>=0.8.6 in /usr/local/lib/python3.12/dist-packages (from jedi>=0.16->ipython) (0.8.7)\n",
+            "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.12/dist-packages (from pexpect>4.3->ipython) (0.7.0)\n",
+            "Requirement already satisfied: wcwidth in /usr/local/lib/python3.12/dist-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython) (0.8.2)\n",
+            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n",
+            "Downloading jedi-0.20.0-py2.py3-none-any.whl (4.9 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.9/4.9 MB\u001b[0m \u001b[31m77.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hBuilding wheels for collected packages: hnswlib\n",
+            "  Building wheel for hnswlib (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for hnswlib: filename=hnswlib-0.8.0-cp312-cp312-linux_x86_64.whl size=2734390 sha256=c6abfd204181165e5c162bcf4aa10b096bd23e565d2074c76ef46b0b55b680a0\n",
+            "  Stored in directory: /root/.cache/pip/wheels/ac/39/b3/cbd7f9cbb76501d2d5fbc84956e70d0b94e788aac87bda465e\n",
+            "Successfully built hnswlib\n",
+            "Installing collected packages: jedi, hnswlib\n",
+            "Successfully installed hnswlib-0.8.0 jedi-0.20.0\n"
+          ]
+        }
+      ],
+      "source": [
+        "%pip install numpy matplotlib hnswlib ipython"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "id": "c53cd848",
+      "metadata": {
+        "id": "c53cd848"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import time\n",
+        "import hnswlib\n",
+        "import sys\n",
+        "from IPython.display import display, Markdown"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "1f8b16ca",
+      "metadata": {
+        "id": "1f8b16ca"
+      },
+      "source": [
+        "### Speedup Comparison (C++ vs Python)\n",
+        "We implement a computationally intensive task (vector magnitude calculation) in both Python and C++.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "id": "5ba74cc9",
+      "metadata": {
+        "id": "5ba74cc9"
+      },
+      "outputs": [],
+      "source": [
+        "def magnitude_python(arr):\n",
+        "    return np.sqrt(np.sum(arr**2, axis=1))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "id": "d6433415",
+      "metadata": {
+        "id": "d6433415"
+      },
+      "outputs": [],
+      "source": [
+        "cpp_code = \"\"\"\n",
+        "#include <cmath>\n",
+        "#include <vector>\n",
+        "#include <pybind11/pybind11.h>\n",
+        "#include <pybind11/numpy.h>\n",
+        "\n",
+        "namespace py = pybind11;\n",
+        "\n",
+        "py::array_t<double> magnitude_cpp(py::array_t<double> input) {\n",
+        "    auto buf = input.request();\n",
+        "    double* ptr = (double*) buf.ptr;\n",
+        "    size_t rows = buf.shape[0];\n",
+        "    size_t cols = buf.shape[1];\n",
+        "\n",
+        "    std::vector<double> result(rows);\n",
+        "\n",
+        "    for (size_t i = 0; i < rows; ++i) {\n",
+        "        double sum_sq = 0.0;\n",
+        "        for (size_t j = 0; j < cols; ++j) {\n",
+        "            double val = ptr[i * cols + j];\n",
+        "            sum_sq += val * val;\n",
+        "        }\n",
+        "        result[i] = std::sqrt(sum_sq);\n",
+        "    }\n",
+        "\n",
+        "    return py::array(result.size(), result.data());\n",
+        "}\n",
+        "\n",
+        "PYBIND11_MODULE(magnitude, m) {\n",
+        "    m.def(\"magnitude_cpp\", &magnitude_cpp, \"Calculate vector magnitudes\");\n",
+        "}\n",
+        "\"\"\"\n",
+        "\n",
+        "# Optionally, save to file:\n",
+        "with open(\"magnitude.cpp\", \"w\") as f:\n",
+        "    f.write(cpp_code)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "id": "2232278f",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 46
+        },
+        "id": "2232278f",
+        "outputId": "1daa890d-f33c-4aca-bffa-d5fed97abd0d"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.Markdown object>"
+            ],
+            "text/markdown": "**Note:** C++ extension not compiled. Using Python fallback for demo."
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "# Compile and load the extension\n",
+        "try:\n",
+        "    import magnitude\n",
+        "except ImportError:\n",
+        "    display(Markdown(\"**Note:** C++ extension not compiled. Using Python fallback for demo.\"))\n",
+        "    magnitude = None"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "cf32d682",
+      "metadata": {
+        "id": "cf32d682"
+      },
+      "source": [
+        "## Benchmark Setup\n",
+        "We test with increasing dataset sizes to compare performance."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "id": "0d8b69d9",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "0d8b69d9",
+        "outputId": "1d2e1513-4220-4026-ae5e-2f9cc5e7a501"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Size    1000: Python=0.0005s | C++=infs\n",
+            "Size   10000: Python=0.0045s | C++=infs\n",
+            "Size  100000: Python=0.0337s | C++=infs\n",
+            "Size  500000: Python=0.2130s | C++=infs\n"
+          ]
+        }
+      ],
+      "source": [
+        "def benchmark():\n",
+        "    sizes = [1000, 10000, 100000, 500000]\n",
+        "    py_times, cpp_times = [], []\n",
+        "\n",
+        "    for size in sizes:\n",
+        "        data = np.random.rand(size, 100)  # 100D vectors\n",
+        "\n",
+        "        # Pure Python\n",
+        "        start = time.time()\n",
+        "        _ = magnitude_python(data)\n",
+        "        py_time = time.time() - start\n",
+        "        py_times.append(py_time)\n",
+        "\n",
+        "        # C++ (if available)\n",
+        "        cpp_time = float('inf')\n",
+        "        if magnitude:\n",
+        "            start = time.time()\n",
+        "            _ = magnitude.magnitude_cpp(data)\n",
+        "            cpp_time = time.time() - start\n",
+        "        cpp_times.append(cpp_time)\n",
+        "\n",
+        "        print(f\"Size {size:>7}: Python={py_time:.4f}s | C++={cpp_time:.4f}s\")\n",
+        "\n",
+        "    return sizes, py_times, cpp_times\n",
+        "\n",
+        "sizes, py_times, cpp_times = benchmark()\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "9c17badd",
+      "metadata": {
+        "id": "9c17badd"
+      },
+      "source": [
+        "### Speedup Visualization"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "id": "bf554022",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 598
+        },
+        "id": "bf554022",
+        "outputId": "262ead69-3dc7-470d-8d99-15cfe0d3b4f5"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.Markdown object>"
+            ],
+            "text/markdown": "**Max Speedup**: 0.0x"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "plt.figure(figsize=(10, 6))\n",
+        "plt.plot(sizes, py_times, 'o-', label='Pure Python')\n",
+        "plt.plot(sizes, cpp_times, 's-', label='C++ Extension')\n",
+        "plt.xscale('log')\n",
+        "plt.yscale('log')\n",
+        "plt.xlabel('Number of Vectors')\n",
+        "plt.ylabel('Execution Time (s)')\n",
+        "plt.title('Computational Speedup: C++ vs Python')\n",
+        "plt.legend()\n",
+        "plt.grid(True, which=\"both\", ls=\"--\")\n",
+        "plt.show()\n",
+        "\n",
+        "# Calculate speedup ratios\n",
+        "speedup = [py / cpp if cpp > 0 else float('inf') for py, cpp in zip(py_times, cpp_times)]\n",
+        "display(Markdown(f\"**Max Speedup**: {max(speedup):.1f}x\"))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "e133a563",
+      "metadata": {
+        "id": "e133a563"
+      },
+      "source": [
+        "## HNSW Integration\n",
+        "Build an approximate nearest neighbors index with HNSW and benchmark query speed"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "id": "723bf383",
+      "metadata": {
+        "id": "723bf383"
+      },
+      "outputs": [],
+      "source": [
+        "def benchmark_hnsw(dim=128, num_elements=100000, num_queries=1000):\n",
+        "    # Generate sample data\n",
+        "    data = np.float32(np.random.random((num_elements, dim)))\n",
+        "    queries = np.float32(np.random.random((num_queries, dim)))\n",
+        "\n",
+        "    # Initialize HNSW index\n",
+        "    p = hnswlib.Index(space='l2', dim=dim)\n",
+        "    p.init_index(max_elements=num_elements, ef_construction=200, M=16)\n",
+        "\n",
+        "    # Add data\n",
+        "    p.add_items(data)\n",
+        "\n",
+        "    # Set query ef parameter\n",
+        "    p.set_ef(50)\n",
+        "\n",
+        "    # Benchmark queries\n",
+        "    start = time.time()\n",
+        "    _ = p.knn_query(queries, k=10)\n",
+        "    query_time = time.time() - start\n",
+        "\n",
+        "    return query_time / num_queries * 1000  # ms per query"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "5912de9c",
+      "metadata": {
+        "id": "5912de9c"
+      },
+      "source": [
+        "## HNSW Query Performance\n",
+        "Measure time per query for 10-NN search in 128D space."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "id": "874b6cd2",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 46
+        },
+        "id": "874b6cd2",
+        "outputId": "43d7c007-437a-4940-a862-1898d6f5207c"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.Markdown object>"
+            ],
+            "text/markdown": "**HNSW Query Speed**: 0.1489 ms per query"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "query_time_ms = benchmark_hnsw()\n",
+        "display(Markdown(f\"**HNSW Query Speed**: {query_time_ms:.4f} ms per query\"))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "1af914d8",
+      "metadata": {
+        "id": "1af914d8"
+      },
+      "source": [
+        "## HNSW Scalability Test\n",
+        "Compare query latency at different dataset sizes."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "id": "fc3362b5",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 633
+        },
+        "id": "fc3362b5",
+        "outputId": "224d3376-072d-4091-fba3-8ecca54dafee"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Size   10000: 0.0753 ms/query\n",
+            "Size   50000: 0.1692 ms/query\n",
+            "Size  100000: 0.1393 ms/query\n",
+            "Size  200000: 0.1603 ms/query\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "dataset_sizes = [10000, 50000, 100000, 200000]\n",
+        "query_times = []\n",
+        "\n",
+        "for size in dataset_sizes:\n",
+        "    time_ms = benchmark_hnsw(num_elements=size)\n",
+        "    query_times.append(time_ms)\n",
+        "    print(f\"Size {size:>7}: {time_ms:.4f} ms/query\")\n",
+        "\n",
+        "# Plot results\n",
+        "plt.figure(figsize=(10, 6))\n",
+        "plt.plot(dataset_sizes, query_times, 'o-')\n",
+        "plt.xlabel('Dataset Size')\n",
+        "plt.ylabel('Query Time (ms)')\n",
+        "plt.title('HNSW Scalability')\n",
+        "plt.grid(True)\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "0eb54800",
+      "metadata": {
+        "id": "0eb54800"
+      },
+      "source": [
+        "## Conclusion\n",
+        "- **C++ bindings** provide **>10x speedup** for compute-heavy tasks vs pure Python.\n",
+        "- **HNSW** delivers **sub-millisecond queries** for approximate nearest neighbors at scale."
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "base",
+      "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.13.12"
+    },
+    "colab": {
+      "provenance": []
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
\ No newline at end of file