gqlite 1.5.0 → 1.7.0

data/ext/gqlitedb/src/store/redb.rs

@@ -1,9 +1,22 @@
 use ccutils::sync::ArcRwLock;
 use redb::{DatabaseError, ReadableDatabase as _, ReadableTable, ReadableTableMetadata as _};
 use serde::{Deserialize, Serialize};
-use std::{cell::RefCell, collections::HashMap, rc::Rc, sync::Arc};
+use std::{
+  cell::RefCell,
+  collections::HashMap,
+  rc::Rc,
+  sync::{Arc, Mutex},
+};
 
-use crate::{prelude::*, store::TransactionBoxable};
+pub(crate) mod index;
+pub(crate) use index::HnswParams;
+pub(crate) mod hnsw_store;
+
+use crate::{
+  prelude::*,
+  store::{Store as StoreTrait, TransactionBoxable},
+};
+use db_index::hnsw::graph_store::GraphStoreRead;
 
 //  ____               _     _             _   _____    _
 // |  _ \ ___ _ __ ___(_)___| |_ ___ _ __ | |_| ____|__| | __ _  ___
@@ -51,6 +64,14 @@ impl redb::Value for PersistentEdge
   }
 }
 
+#[derive(Serialize)]
+struct NodeSerializer<'a>
+{
+  pub key: graphcore::Key,
+  pub labels: &'a Vec<String>,
+  pub properties: &'a value::ValueMap,
+}
+
 #[derive(Debug)]
 enum PersistentNode<'a>
 {
@@ -70,8 +91,6 @@ impl<'a> From<PersistentNode<'a>> for graph::Node
   }
 }
 
-// ccutils::alias!(PersistentNode, graph::Node, derive: Debug, Deserialize, Serialize, Clone);
-
 impl<'c> redb::Value for PersistentNode<'c>
 {
   type AsBytes<'a>
@@ -87,11 +106,20 @@ impl<'c> redb::Value for PersistentNode<'c>
     Self: 'b,
   {
     let mut data = Vec::<u8>::new();
-    match value
+    let node_serialization = match value
     {
-      PersistentNode::Reference(refe) => ciborium::into_writer(refe, &mut data).unwrap(), // This unwrap should not happen, unless there is a bug
-      PersistentNode::Value(refe) => ciborium::into_writer(&refe, &mut data).unwrap(), // This unwrap should not happen, unless there is a bug
-    }
+      PersistentNode::Reference(refe) => NodeSerializer {
+        key: refe.key(),
+        labels: refe.labels(),
+        properties: refe.properties(),
+      },
+      PersistentNode::Value(value) => NodeSerializer {
+        key: value.key(),
+        labels: value.labels(),
+        properties: value.properties(),
+      },
+    };
+    ciborium::into_writer(&node_serialization, &mut data).unwrap(); // This unwrap should not happen, unless there is a bug
     data
   }
   fn from_bytes<'a>(data: &'a [u8]) -> Self::SelfType<'a>
@@ -110,7 +138,11 @@ impl<'c> redb::Value for PersistentNode<'c>
   }
 }
 
-ccutils::alias!(PersistentKey, graph::Key, derive: Debug, Deserialize, Serialize, PartialEq, Clone);
+ccutils::alias!(
+  #[derive(Debug, Deserialize, Serialize, PartialEq, Clone)]
+  PersistentKey,
+  graph::Key
+);
 
 impl PersistentKey
 {
@@ -247,6 +279,7 @@ struct GraphInfo
   edges_table: String,
   edges_source_index: String,
   edges_destination_index: String,
+  index_registry: index::IndexRegistry,
 }
 
 impl GraphInfo
@@ -258,6 +291,7 @@ impl GraphInfo
     let edges_table = format!("__{}__edges_table", name);
     let edges_source_index = format!("__{}__edges_source_index", name);
     let edges_destination_index = format!("__{}__edges_destination_index", name);
+    let index_registry = index::IndexRegistry::new();
 
     GraphInfo {
       name,
@@ -265,8 +299,10 @@ impl GraphInfo
       edges_table,
       edges_source_index,
       edges_destination_index,
+      index_registry,
     }
   }
+
   fn nodes_table_definition<'a, 'b>(
     &'a self,
   ) -> redb::TableDefinition<'a, PersistentKey, PersistentNode<'b>>
@@ -293,6 +329,48 @@ impl GraphInfo
   }
 }
 
+/// Shape of a legacy (pre-1.7-unification) per-index metadata JSON blob,
+/// as written by create_vector_index at the 1.7 tag.
+#[derive(Deserialize)]
+struct LegacyVectorIndexMetadata
+{
+  name: String,
+  label: Option<String>,
+  property: Option<String>,
+  dimension: usize,
+  metric: String, // Debug-formatted, e.g. "Cosine" -- via from_debug_str
+  hnsw_m: usize,
+  hnsw_ef_construction: usize,
+  hnsw_ef_search: usize,
+  dtype: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub(crate) enum IndexMetadata
+{
+  VectorIndex
+  {
+    name: String,
+    label: Option<String>,
+    property: Option<String>,
+    dimension: usize,
+    metric: super::VectorMetric,
+    hnsw_params: HnswParams,
+    dtype: String,
+  },
+}
+
+impl IndexMetadata
+{
+  fn name(&self) -> &str
+  {
+    match self
+    {
+      Self::VectorIndex { name, .. } => name,
+    }
+  }
+}
+
 //  _____                          _   _
 // |_   _| __ __ _ _ __  ___  __ _| |_(_) ___  _ __
 //   | || '__/ _` | '_ \/ __|/ _` | __| |/ _ \| '_ \
@@ -307,19 +385,29 @@ impl super::ReadTransaction for redb::ReadTransaction
   }
 }
 
-impl super::ReadTransaction for redb::WriteTransaction
+#[expect(dead_code)]
+pub(crate) type NodeTensorPair = (graph::Key, value::Tensor);
+
+pub(crate) struct WriteTransaction
+{
+  pub(crate) write_transaction: redb::WriteTransaction,
+}
+
+impl WriteTransaction {}
+
+impl super::ReadTransaction for WriteTransaction
 {
   fn discard(self) -> Result<()>
   {
-    Ok(self.abort()?)
+    Ok(self.write_transaction.abort()?)
   }
 }
 
-impl super::WriteTransaction for redb::WriteTransaction
+impl super::WriteTransaction for WriteTransaction
 {
   fn commit(self) -> Result<()>
   {
-    Ok(self.commit()?)
+    Ok(self.write_transaction.commit()?)
   }
 }
 
@@ -334,14 +422,55 @@ pub(crate) struct Store
 {
   redb_store: redb::Database,
   graphs: ArcRwLock<HashMap<String, Arc<GraphInfo>>>,
+  // Track creation order of nodes for deterministic vector search results
+  node_sequence_counter: Mutex<u64>,
+  node_sequences: Mutex<HashMap<graph::Key, u64>>,
 }
 
 ccutils::assert_impl_all!(Store: Sync, Send);
 
-type TransactionBox = store::TransactionBox<redb::ReadTransaction, redb::WriteTransaction>;
+type TransactionBox = store::TransactionBox<redb::ReadTransaction, WriteTransaction>;
 
 impl Store
 {
+  fn index_metadata_key(graph_name: &str) -> String
+  {
+    format!("{}__index_metadata", graph_name)
+  }
+
+  pub(crate) fn get_graph_index_metadata(
+    &self,
+    transaction: &mut TransactionBox,
+    graph_name: &str,
+  ) -> Result<Vec<IndexMetadata>>
+  {
+    Self::get_metadata_value_or_else(
+      transaction,
+      Self::index_metadata_key(graph_name),
+      Default::default,
+    )
+  }
+
+  pub(crate) fn set_graph_index_metadata(
+    &self,
+    transaction: &mut TransactionBox,
+    graph_name: &str,
+    metadata: &[IndexMetadata],
+  ) -> Result<()>
+  {
+    Self::set_metadata_value(transaction, Self::index_metadata_key(graph_name), &metadata)
+  }
+
+  fn graphs_list_read(&self, read_tx: &redb::ReadTransaction) -> Result<Vec<String>>
+  {
+    match Self::get_metadata_raw_read(read_tx, "graphs")
+    {
+      Ok(data) => Ok(ciborium::from_reader(data.as_slice())?),
+      Err(Error::Internal(InternalError::MissingMetadata { .. })) => Ok(Vec::new()),
+      Err(e) => Err(e),
+    }
+  }
+
   /// Crate a new store, with a default graph
   pub(crate) fn open<P: AsRef<std::path::Path>>(path: P) -> Result<Store>
   {
@@ -374,10 +503,13 @@ impl Store
     let s = Self {
       redb_store,
       graphs: Default::default(),
+      node_sequence_counter: Mutex::new(0),
+      node_sequences: Mutex::new(HashMap::new()),
     };
     s.initialise()?;
     Ok(s)
   }
+
   /// Crate a new store, with a default graph, in memory
   pub(crate) fn in_memory() -> Result<Store>
   {
@@ -385,22 +517,295 @@ impl Store
       redb_store: redb::Database::builder()
         .create_with_backend(redb::backends::InMemoryBackend::new())?,
       graphs: Default::default(),
+      node_sequence_counter: Mutex::new(0),
+      node_sequences: Mutex::new(HashMap::new()),
     };
     s.initialise()?;
     Ok(s)
   }
   fn initialise(&self) -> Result<()>
   {
-    use crate::store::Store;
     let mut tx = self.begin_write()?;
+
+    // A genuinely fresh database (first-ever open) has no graphs and therefore cannot have a version
+    // key yet -- this is expected, not an error case.
+    let is_new_database = self.graphs_list(&mut tx)?.is_empty();
+
     self.create_graph(&mut tx, "default", true)?;
-    self.set_metadata_value(&mut tx, "version", &consts::GQLITE_VERSION)?;
+
+    if is_new_database
+    {
+      Self::set_metadata_value(&mut tx, "version", &consts::GQLITE_VERSION)?;
+    }
+    else
+    {
+      match Self::get_metadata_value::<utils::Version>(&mut tx, "version")
+      {
+        Ok(v) if v == consts::GQLITE_VERSION =>
+        {
+          // Already current -- no migration work.
+        }
+        Ok(v) =>
+        {
+          self.upgrade_database(v, &mut tx)?;
+          Self::set_metadata_value(&mut tx, "version", &consts::GQLITE_VERSION)?;
+        }
+        Err(_) =>
+        {
+          // Existing, populated database with no version metadata at all.
+          // Every database this store has ever created writes this key unconditionally -- refuse to
+          // guess an assumed starting version and silently rewrite an unrecognized or corrupted file.
+          return Err(StoreError::MissingVersionMetadata.into());
+        }
+      }
+    }
+
     tx.close()?;
+    self.reload_persisted_graph_state()?;
     Ok(())
   }
-  #[allow(dead_code)]
-  fn get_metadata_from_table<TTable, TValue>(
+
+  /// Walks the database forward from `from` to `consts::GQLITE_VERSION`, one version step at a time.
+  /// Mirrors sqlite.rs's upgrade_database dispatch shape. Each arm only knows how to bring the
+  /// database forward exactly one step; the function recurses until `from` matches current.
+  fn upgrade_database(&self, from: utils::Version, tx: &mut TransactionBox) -> Result<()>
+  {
+    if from == consts::GQLITE_VERSION
+    {
+      return Ok(());
+    }
+
+    match (from.major, from.minor, from.patch)
+    {
+      (1, minor, _) if minor <= 7 =>
+      {
+        self.upgrade_from_1_7(tx)?;
+        self.upgrade_database(
+          utils::Version {
+            major: 1,
+            minor: 8,
+            patch: 0,
+          },
+          tx,
+        )
+      }
+      _ => Err(
+        StoreError::IncompatibleVersion {
+          expected: consts::GQLITE_VERSION,
+          actual: from,
+        }
+        .into(),
+      ),
+    }
+  }
+
+  /// Finds every legacy (pre-1.7-unification) per-index metadata key for the
+  /// given graph, in the form "{graph_name}__vector_index_{index_name}".
+  fn find_legacy_vector_index_keys(
+    &self,
+    tx: &mut TransactionBox,
+    graph_name: &str,
+  ) -> Result<Vec<String>>
+  {
+    let prefix = format!("{}__vector_index_", graph_name);
+    let prefix_end = format!("{}__vector_index_\x7F", graph_name);
+    let table_def = redb::TableDefinition::<String, Vec<u8>>::new("gqlite_metadata");
+
+    match tx
+    {
+      TransactionBox::Read(read) =>
+      {
+        let table = read.open_table(table_def)?;
+        table
+          .range::<String>(prefix.clone()..=prefix_end)?
+          .map(|entry| {
+            entry
+              .map(|(k, _)| k.value().to_string())
+              .map_err(Into::into)
+          })
+          .collect()
+      }
+      TransactionBox::Write(write) =>
+      {
+        let table = write.write_transaction.open_table(table_def)?;
+        table
+          .range::<String>(prefix.clone()..=prefix_end)?
+          .map(|entry| {
+            entry
+              .map(|(k, _)| k.value().to_string())
+              .map_err(Into::into)
+          })
+          .collect()
+      }
+    }
+  }
+  /// Reads and translates one legacy per-index metadata JSON blob into the
+  /// current IndexMetadata::VectorIndex shape. Uses serde deserialization
+  /// for clean and type-safe parsing.
+  pub(crate) fn translate_legacy_vector_index_metadata(
     &self,
+    tx: &mut TransactionBox,
+    legacy_key: &str,
+  ) -> Result<IndexMetadata>
+  {
+    let legacy: LegacyVectorIndexMetadata = Self::get_metadata_value(tx, legacy_key)?;
+
+    Ok(IndexMetadata::VectorIndex {
+      name: legacy.name,
+      label: legacy.label,
+      property: legacy.property,
+      dimension: legacy.dimension,
+      metric: super::VectorMetric::from_debug_str(&legacy.metric),
+      hnsw_params: HnswParams {
+        m: legacy.hnsw_m,
+        ef_construction: legacy.hnsw_ef_construction,
+        ef_search: legacy.hnsw_ef_search,
+      },
+      dtype: legacy.dtype,
+    })
+  }
+
+  /// Upgrade from 1.7 to 1.8. The vector index storage format was changed and need migration.
+  fn upgrade_from_1_7(&self, tx: &mut TransactionBox) -> Result<()>
+  {
+    let graphs = self.graphs_list(tx)?;
+
+    for graph_name in graphs
+    {
+      let legacy_keys = self.find_legacy_vector_index_keys(tx, &graph_name)?;
+
+      for legacy_key in &legacy_keys
+      {
+        let IndexMetadata::VectorIndex {
+          name,
+          dimension,
+          metric,
+          hnsw_params: params,
+          property,
+          ..
+        } = self.translate_legacy_vector_index_metadata(tx, legacy_key)?;
+
+        self.create_vector_index(
+          tx,
+          &graph_name,
+          super::VectorIndexSpec {
+            name,
+            dimension,
+            metric,
+            hnsw_params: params,
+            property,
+            ..Default::default()
+          },
+        )?;
+      }
+
+      // Clean up legacy keys.
+      if !legacy_keys.is_empty()
+      {
+        let tx_write = tx.try_into_write()?;
+        let mut metadata_table = tx_write
+          .write_transaction
+          .open_table(redb::TableDefinition::<String, Vec<u8>>::new(
+            "gqlite_metadata",
+          ))?;
+        for legacy_key in &legacy_keys
+        {
+          metadata_table.remove(legacy_key)?;
+        }
+      }
+    }
+
+    Ok(())
+  }
+
+  fn reload_persisted_graph_state(&self) -> Result<()>
+  {
+    let read_tx = self.redb_store.begin_read()?;
+    for graph_name in self.graphs_list_read(&read_tx)?
+    {
+      self.register_vector_indexes(&read_tx, &graph_name)?;
+    }
+    Ok(())
+  }
+
+  fn register_vector_indexes(&self, read_tx: &redb::ReadTransaction, graph_name: &str)
+  -> Result<()>
+  {
+    let meta_key = Self::index_metadata_key(graph_name);
+    let index_metadata_list = match Self::get_metadata_raw_read(read_tx, &meta_key)
+    {
+      Ok(data) => ciborium::from_reader::<Vec<IndexMetadata>, _>(data.as_slice())?,
+      Err(Error::Internal(InternalError::MissingMetadata { .. })) => Vec::new(),
+      Err(e) => return Err(e),
+    };
+
+    let graph_info = self.get_graph_info(graph_name)?;
+    let registry = &graph_info.index_registry;
+
+    for metadata in index_metadata_list.iter()
+    {
+      let index_name = metadata.name();
+      // Skip if already registered (should not happen at startup).
+      if registry.get_index(index_name).is_some()
+      {
+        continue;
+      }
+
+      // Create and register the index in memory.
+      // The persistent store is the source of truth; no loading or reconstruction needed.
+      let (kind, property) = match metadata
+      {
+        IndexMetadata::VectorIndex {
+          dimension,
+          metric,
+          property,
+          hnsw_params,
+          ..
+        } => (
+          index::IndexKind::Vector {
+            dimension: *dimension,
+            metric: *metric,
+            params: hnsw_params.to_owned(),
+          },
+          property.clone(),
+        ),
+      };
+      let idx = index::create_index(kind, index_name, property);
+      registry.register_index(index_name.to_string(), idx);
+    }
+    Ok(())
+  }
+  fn get_metadata_raw_from_table<TTable>(table: TTable, key: impl Into<String>) -> Result<Vec<u8>>
+  where
+    TTable: ReadableTable<String, Vec<u8>>,
+  {
+    let key = key.into();
+    let value = table
+      .get(&key)?
+      .ok_or_else(|| InternalError::MissingMetadata { key })?;
+    Ok(value.value())
+  }
+  #[expect(dead_code)]
+  fn get_metadata_raw_write(
+    transaction: &WriteTransaction,
+    key: impl Into<String>,
+  ) -> Result<Vec<u8>>
+  {
+    let table_def = redb::TableDefinition::new("gqlite_metadata");
+    Self::get_metadata_raw_from_table(
+      transaction.write_transaction.open_table(table_def)?,
+      key.into(),
+    )
+  }
+  fn get_metadata_raw_read(
+    transaction: &redb::ReadTransaction,
+    key: impl Into<String>,
+  ) -> Result<Vec<u8>>
+  {
+    let table_def = redb::TableDefinition::new("gqlite_metadata");
+    Self::get_metadata_raw_from_table(transaction.open_table(table_def)?, key.into())
+  }
+  fn get_metadata_from_table<TTable, TValue>(
     table: TTable,
     key: impl Into<String>,
   ) -> Result<TValue>
@@ -414,9 +819,7 @@ impl Store
       .ok_or_else(|| InternalError::MissingMetadata { key })?;
     Ok(ciborium::from_reader(value.value().as_slice())?)
   }
-  #[allow(dead_code)]
   fn get_metadata_value<T: for<'a> Deserialize<'a>>(
-    &self,
     transaction: &mut TransactionBox,
     key: impl Into<String>,
   ) -> Result<T>
@@ -426,16 +829,15 @@ impl Store
     {
       TransactionBox::Read(read) =>
       {
-        self.get_metadata_from_table(read.open_table(table_def)?, key.into())
+        Self::get_metadata_from_table(read.open_table(table_def)?, key.into())
       }
       TransactionBox::Write(write) =>
       {
-        self.get_metadata_from_table(write.open_table(table_def)?, key.into())
+        Self::get_metadata_from_table(write.write_transaction.open_table(table_def)?, key.into())
       }
     }
   }
   fn get_metadata_value_or_else_from_table<TTable, TValue>(
-    &self,
     table: TTable,
     key: impl Into<String>,
     f: impl FnOnce() -> TValue,
@@ -452,7 +854,6 @@ impl Store
     Ok(value)
   }
   fn get_metadata_value_or_else<T: for<'a> Deserialize<'a>>(
-    &self,
     transaction: &mut TransactionBox,
     key: impl Into<String>,
     f: impl FnOnce() -> T,
@@ -463,31 +864,52 @@ impl Store
     {
       TransactionBox::Read(read) =>
       {
-        self.get_metadata_value_or_else_from_table(read.open_table(table_def)?, key.into(), f)
-      }
-      TransactionBox::Write(write) =>
-      {
-        self.get_metadata_value_or_else_from_table(write.open_table(table_def)?, key.into(), f)
+        Self::get_metadata_value_or_else_from_table(read.open_table(table_def)?, key.into(), f)
       }
+      TransactionBox::Write(write) => Self::get_metadata_value_or_else_from_table(
+        write.write_transaction.open_table(table_def)?,
+        key.into(),
+        f,
+      ),
     }
   }
+  fn set_metadata_raw(
+    transaction: &WriteTransaction,
+    key: impl Into<String>,
+    data: Vec<u8>,
+  ) -> Result<()>
+  {
+    let mut metadata_table =
+      transaction.write_transaction.open_table(
+        redb::TableDefinition::<'_, String, Vec<u8>>::new("gqlite_metadata"),
+      )?;
+    let key = key.into();
+    metadata_table.insert(&key, data)?;
+    Ok(())
+  }
   fn set_metadata_value<T: Serialize>(
-    &self,
     transaction: &mut TransactionBox,
     key: impl Into<String>,
     value: &T,
   ) -> Result<()>
   {
     let tx = transaction.try_into_write()?;
-    let mut metadata_table = tx.open_table(redb::TableDefinition::<'_, String, Vec<u8>>::new(
-      "gqlite_metadata",
-    ))?;
-    let key = key.into();
     let mut data = Vec::<u8>::new();
     ciborium::into_writer(value, &mut data)?;
-    metadata_table.insert(&key, data)?;
+    Self::set_metadata_raw(tx, key, data)
+  }
+  #[expect(dead_code)]
+  fn remove_metadata_value(transaction: &WriteTransaction, key: impl Into<String>) -> Result<()>
+  {
+    let mut metadata_table =
+      transaction.write_transaction.open_table(
+        redb::TableDefinition::<'_, String, Vec<u8>>::new("gqlite_metadata"),
+      )?;
+    let key = key.into();
+    metadata_table.remove(key)?;
     Ok(())
   }
+
   fn get_graph_info(&self, graph_name: impl AsRef<str>) -> Result<Arc<GraphInfo>>
   {
     let graph_name = graph_name.as_ref();
@@ -510,12 +932,14 @@ impl Store
   }
   fn select_nodes_from_table<T>(
     &self,
+    graph_name: impl AsRef<str>,
     nodes_table: &T,
     query: &super::SelectNodeQuery,
   ) -> Result<Vec<crate::graph::Node>>
   where
     T: ReadableTable<PersistentKey, PersistentNode<'static>>,
   {
+    let graph_name = graph_name.as_ref();
     let r = match &query.keys
     {
       Some(keys) => Box::new(keys.iter().map(|key| {
@@ -581,13 +1005,16 @@ impl Store
       })) as Box<dyn Iterator<Item = Result<crate::graph::Node>>>,
       None => Box::new(r) as Box<dyn Iterator<Item = Result<crate::graph::Node>>>,
     };
-    r.collect()
+    r.map(|n| n.map(|n| n.with_graph_name(graph_name)))
+      .collect()
   }
 
+  #[allow(clippy::too_many_arguments)]
   fn select_edges_from_tables<TEdges, TNodes, TEdgesIndex>(
     &self,
+    graph_name: impl AsRef<str>,
     query: super::SelectEdgeQuery,
-    directivity: graph::EdgeDirectivity,
+    directivity: graphcore::EdgeDirectivity,
     edges_table: TEdges,
     nodes_table: TNodes,
     edges_source_index: Rc<RefCell<TEdgesIndex>>,
@@ -598,10 +1025,11 @@ impl Store
     TNodes: ReadableTable<PersistentKey, PersistentNode<'static>>,
     TEdgesIndex: ReadableTable<PersistentKey, Vec<PersistentKey>>,
   {
+    let graph_name = graph_name.as_ref();
     let edges_uuid_indices = match directivity
     {
-      graph::EdgeDirectivity::Directed => vec![(edges_source_index, edges_destination_index)],
-      graph::EdgeDirectivity::Undirected => vec![
+      graphcore::EdgeDirectivity::Directed => vec![(edges_source_index, edges_destination_index)],
+      graphcore::EdgeDirectivity::Undirected => vec![
         (edges_source_index.clone(), edges_destination_index.clone()),
         (edges_destination_index, edges_source_index),
       ],
@@ -645,7 +1073,8 @@ impl Store
           {
             if !query.destination.is_select_all() && !query.source.is_select_all()
             {
-              let dest_it = self.select_nodes_from_table(&nodes_table, &query.destination)?;
+              let dest_it =
+                self.select_nodes_from_table(graph_name, &nodes_table, &query.destination)?;
               let dest_it: Vec<graph::Key> = dest_it
                 .into_iter()
                 .map(|n| {
@@ -661,7 +1090,7 @@ impl Store
                 .into_iter()
                 .flatten()
                 .collect();
-              let nodes = self.select_nodes_from_table(&nodes_table, &query.source)?;
+              let nodes = self.select_nodes_from_table(graph_name, &nodes_table, &query.source)?;
               for n in nodes.iter()
               {
                 let nkey = n.key();
@@ -693,7 +1122,7 @@ impl Store
             }
             else if !query.source.is_select_all()
             {
-              let nodes = self.select_nodes_from_table(&nodes_table, &query.source)?;
+              let nodes = self.select_nodes_from_table(graph_name, &nodes_table, &query.source)?;
 
               for n in nodes.into_iter()
               {
@@ -723,7 +1152,8 @@ impl Store
             }
             else
             {
-              let nodes = self.select_nodes_from_table(&nodes_table, &query.destination)?;
+              let nodes =
+                self.select_nodes_from_table(graph_name, &nodes_table, &query.destination)?;
               for n in nodes.into_iter()
               {
                 let nkey = n.key();
@@ -771,13 +1201,12 @@ impl Store
           .value()
           .into();
 
-        let edge = graph::Path::new(
-          edge.key.into(),
+        let edge = graph::SinglePath::new(
           source,
-          edge.labels,
-          edge.properties,
+          graph::Edge::new(None, edge.key.into(), edge.labels, edge.properties),
           destination,
-        );
+        )
+        .with_graph_name(graph_name.to_string());
         super::EdgeResult {
           path: edge,
           reversed,
@@ -845,12 +1274,153 @@ impl Store
           true
         }
       })
+      .map(|e| {
+        e.map(|mut e| {
+          e.path = e.path.with_graph_name(graph_name);
+          e
+        })
+      })
       .collect()
     }
     else
     {
-      r.collect()
+      r.map(|e| {
+        e.map(|mut e| {
+          e.path = e.path.with_graph_name(graph_name);
+          e
+        })
+      })
+      .collect()
+    }
+  }
+
+  /// Increment the epoch for a vector index after a successful vector update
+  #[allow(dead_code)]
+  pub(crate) fn increment_vector_index_epoch(
+    &self,
+    transaction: &mut TransactionBox,
+    graph_name: &str,
+    index_name: &str,
+  ) -> Result<u64>
+  {
+    let key = format!("vector_index_epoch:{}:{}", graph_name, index_name);
+    let current = Self::get_metadata_value_or_else(transaction, &key, || 0u64)?;
+    let new_epoch = current + 1;
+    Self::set_metadata_value(transaction, &key, &new_epoch)?;
+    Ok(new_epoch)
+  }
+
+  pub(crate) fn drop_index(
+    &self,
+    transaction: &mut TransactionBox,
+    graph_name: impl AsRef<str>,
+    name: impl AsRef<str>,
+  ) -> Result<()>
+  {
+    let graph_name = graph_name.as_ref();
+    let name = name.as_ref();
+    let graph_info = self.get_graph_info(graph_name)?;
+    if graph_info.index_registry.drop_index(name).is_none()
+    {
+      return Err(
+        StoreError::InvalidFormat(format!(
+          "Vector index '{}' does not exist in graph '{}'",
+          name, graph_name
+        ))
+        .into(),
+      );
+    }
+
+    // Remove metadata and HNSW tables in a single write block
+    // Note: We defer table deletion to avoid redb transaction issues
+    {
+      let tx = transaction.try_into_write()?;
+      let mut metadata_table = tx.write_transaction.open_table(redb::TableDefinition::<
+        '_,
+        String,
+        Vec<u8>,
+      >::new("gqlite_metadata"))?;
+
+      // Remove epoch metadata
+      let epoch_key = format!("vector_index_epoch:{}:{}", graph_name, name);
+      let _ = metadata_table.remove(&epoch_key);
+
+      // Note: HNSW tables are left in redb but marked as orphaned.
+      // Deleting them in the same write transaction causes redb to fail.
+      // Tables will be cleaned up if the index is recreated.
+    }
+
+    let mut metadata = self.get_graph_index_metadata(transaction, graph_name)?;
+    metadata.retain(|entry| entry.name() != name);
+    self.set_graph_index_metadata(transaction, graph_name, &metadata)?;
+
+    Ok(())
+  }
+
+  #[cfg(test)]
+  #[allow(dead_code)]
+  pub(crate) fn get_index_hnsw_parameters(
+    &self,
+    graph_name: &str,
+    index_name: &str,
+  ) -> Result<Option<HnswParams>>
+  {
+    let graph_info = self.get_graph_info(graph_name)?;
+    let registry = &graph_info.index_registry;
+    if let Some(index) = registry.get_index(index_name)
+      && let Some(hnsw_idx) = index.as_any().downcast_ref::<index::HnswVectorIndex>()
+    {
+      return Ok(Some(hnsw_idx.get_hnsw_parameters()));
     }
+
+    let mut transaction = self.begin_read()?;
+    let metadata_list = self.get_graph_index_metadata(&mut transaction, graph_name)?;
+    transaction.close()?;
+    for metadata in metadata_list
+    {
+      if let IndexMetadata::VectorIndex {
+        name, hnsw_params, ..
+      } = metadata
+        && name == index_name
+      {
+        return Ok(Some(hnsw_params));
+      }
+    }
+
+    Ok(None)
+  }
+
+  #[cfg(test)]
+  pub(crate) fn test_hnsw_table_row_counts(
+    &self,
+    graph_name: &str,
+    index_name: &str,
+  ) -> Result<(usize, usize, usize)>
+  {
+    use redb::ReadableTableMetadata as _;
+    let tables = hnsw_store::HnswTableSet::new(graph_name, index_name);
+    let read_tx = self.redb_store.begin_read()?;
+
+    let adj_len = match read_tx.open_table(tables.adj())
+    {
+      Ok(t) => t.len()? as usize,
+      Err(redb::TableError::TableDoesNotExist(_)) => 0,
+      Err(e) => return Err(e.into()),
+    };
+    let vec_len = match read_tx.open_table(tables.vec())
+    {
+      Ok(t) => t.len()? as usize,
+      Err(redb::TableError::TableDoesNotExist(_)) => 0,
+      Err(e) => return Err(e.into()),
+    };
+    let key_len = match read_tx.open_table(tables.key())
+    {
+      Ok(t) => t.len()? as usize,
+      Err(redb::TableError::TableDoesNotExist(_)) => 0,
+      Err(e) => return Err(e.into()),
+    };
+
+    Ok((adj_len, vec_len, key_len))
   }
 }
 
@@ -861,7 +1431,10 @@ impl store::Store for Store
   fn begin_write(&self) -> Result<Self::TransactionBox>
   {
     let s = self.redb_store.begin_write()?;
-    Ok(Self::TransactionBox::from_write(s))
+    let wrapped = WriteTransaction {
+      write_transaction: s,
+    };
+    Ok(Self::TransactionBox::from_write(wrapped))
   }
   fn begin_read(&self) -> Result<Self::TransactionBox>
   {
@@ -870,7 +1443,7 @@ impl store::Store for Store
   }
   fn graphs_list(&self, transaction: &mut Self::TransactionBox) -> Result<Vec<String>>
   {
-    self.get_metadata_value_or_else(transaction, "graphs".to_string(), Vec::new)
+    Self::get_metadata_value_or_else(transaction, "graphs".to_string(), Vec::new)
   }
   fn create_graph(
     &self,
@@ -902,15 +1475,20 @@ impl store::Store for Store
       let tx = transaction.try_into_write()?;
 
       let gi = Arc::new(GraphInfo::new(graph_name));
-      tx.open_table(gi.nodes_table_definition())?;
-      tx.open_table(gi.edges_table_definition())?;
-      tx.open_table(gi.edges_source_index_definition())?;
-      tx.open_table(gi.edges_destination_index_definition())?;
+      tx.write_transaction
+        .open_table(gi.nodes_table_definition())?;
+      tx.write_transaction
+        .open_table(gi.edges_table_definition())?;
+      tx.write_transaction
+        .open_table(gi.edges_source_index_definition())?;
+      tx.write_transaction
+        .open_table(gi.edges_destination_index_definition())?;
 
       self.graphs.write()?.insert(graph_name.to_owned(), gi);
     }
     graphs_list.push(graph_name.to_owned());
-    self.set_metadata_value(transaction, "graphs", &graphs_list)?;
+    Self::set_metadata_value(transaction, "graphs", &graphs_list)?;
+    self.set_graph_index_metadata(transaction, graph_name, &[])?;
 
     Ok(())
   }
@@ -925,16 +1503,42 @@ impl store::Store for Store
     let mut graphs_list = self.graphs_list(transaction)?;
     if graphs_list.iter().any(|s| s == graph_name)
     {
+      let index_names: Vec<String> = self
+        .get_graph_info(graph_name)?
+        .index_registry
+        .iter_indexes()
+        .into_iter()
+        .map(|index| index.name().to_owned())
+        .collect();
+      for index_name in index_names
+      {
+        self.drop_vector_index(transaction, graph_name, &index_name)?;
+      }
+
       {
         let tx = transaction.try_into_write()?;
         let graph_info = self.get_graph_info(graph_name)?;
-        tx.delete_table(graph_info.nodes_table_definition())?;
-        tx.delete_table(graph_info.edges_table_definition())?;
-        tx.delete_table(graph_info.edges_source_index_definition())?;
-        tx.delete_table(graph_info.edges_destination_index_definition())?;
+        tx.write_transaction
+          .delete_table(graph_info.nodes_table_definition())?;
+        tx.write_transaction
+          .delete_table(graph_info.edges_table_definition())?;
+        tx.write_transaction
+          .delete_table(graph_info.edges_source_index_definition())?;
+        tx.write_transaction
+          .delete_table(graph_info.edges_destination_index_definition())?;
       }
+      self.graphs.write()?.remove(graph_name);
       graphs_list.retain(|x| x != graph_name);
-      self.set_metadata_value(transaction, "graphs", &graphs_list)?;
+      Self::set_metadata_value(transaction, "graphs", &graphs_list)?;
+      {
+        let tx = transaction.try_into_write()?;
+        let mut metadata_table =
+          tx.write_transaction
+            .open_table(redb::TableDefinition::<'_, String, Vec<u8>>::new(
+              "gqlite_metadata",
+            ))?;
+        metadata_table.remove(&Self::index_metadata_key(graph_name))?;
+      }
 
       Ok(())
     }
@@ -960,18 +1564,39 @@ impl store::Store for Store
     nodes_iter: T,
   ) -> Result<()>
   {
+    let graph_name = graph_name.as_ref();
     let graph_info = self.get_graph_info(graph_name)?;
     let transaction = transaction.try_into_write()?;
-    let mut table = transaction.open_table(graph_info.nodes_table_definition())?;
-    let mut table_source = transaction.open_table(graph_info.edges_source_index_definition())?;
-    let mut table_destination =
-      transaction.open_table(graph_info.edges_destination_index_definition())?;
-    for x in nodes_iter
+    let mut table = transaction
+      .write_transaction
+      .open_table(graph_info.nodes_table_definition())?;
+    let mut table_source = transaction
+      .write_transaction
+      .open_table(graph_info.edges_source_index_definition())?;
+    let mut table_destination = transaction
+      .write_transaction
+      .open_table(graph_info.edges_destination_index_definition())?;
+    let registry = &graph_info.index_registry;
+    for node in nodes_iter
     {
-      let pk = PersistentKey(x.key());
-      table.insert(&pk, PersistentNode::Reference(x))?;
+      let pk = PersistentKey(node.key());
+
+      // Track creation sequence for deterministic vector search tiebreaking
+      let sequence = {
+        let mut counter = self.node_sequence_counter.lock().unwrap();
+        *counter += 1;
+        *counter
+      };
+      let mut sequences = self.node_sequences.lock().unwrap();
+      sequences.insert(node.key(), sequence);
+
+      table.insert(&pk, PersistentNode::Reference(node))?;
       table_source.insert(&pk, vec![])?;
       table_destination.insert(&pk, vec![])?;
+      for idx in registry.iter_indexes()
+      {
+        let _ = idx.on_insert(node);
+      }
     }
     Ok(())
   }
@@ -983,10 +1608,33 @@ impl store::Store for Store
     node: &graph::Node,
   ) -> Result<()>
   {
+    let graph_name = graph_name.as_ref();
     let graph_info = self.get_graph_info(graph_name)?;
     let transaction = transaction.try_into_write()?;
-    let mut table = transaction.open_table(graph_info.nodes_table_definition())?;
-    table.insert(PersistentKey(node.key()), PersistentNode::Reference(node))?;
+    let mut table = transaction
+      .write_transaction
+      .open_table(graph_info.nodes_table_definition())?;
+    let pk = PersistentKey(node.key());
+    let maybe_old_node: Option<crate::graph::Node> =
+      table.get(pk.clone())?.map(|g| g.value().into());
+    if let Some(old_node) = maybe_old_node
+    {
+      table.insert(pk, PersistentNode::Reference(node))?;
+      let registry = &graph_info.index_registry;
+      for idx in registry.iter_indexes()
+      {
+        idx.on_update(&old_node, node)?;
+      }
+    }
+    else
+    {
+      table.insert(pk, PersistentNode::Reference(node))?;
+      let registry = &graph_info.index_registry;
+      for idx in registry.iter_indexes()
+      {
+        idx.on_insert(node)?;
+      }
+    }
     Ok(())
   }
   /// Delete nodes according to a given query
@@ -1006,23 +1654,41 @@ impl store::Store for Store
       let write_transaction = transaction.try_into_write()?;
       if detach
       {
-        write_transaction.delete_table(graph_info.edges_table_definition())?;
-        write_transaction.delete_table(graph_info.edges_source_index_definition())?;
-        write_transaction.delete_table(graph_info.edges_destination_index_definition())?;
-        write_transaction.open_table(graph_info.edges_table_definition())?;
-        write_transaction.open_table(graph_info.edges_source_index_definition())?;
-        write_transaction.open_table(graph_info.edges_destination_index_definition())?;
+        write_transaction
+          .write_transaction
+          .delete_table(graph_info.edges_table_definition())?;
+        write_transaction
+          .write_transaction
+          .delete_table(graph_info.edges_source_index_definition())?;
+        write_transaction
+          .write_transaction
+          .delete_table(graph_info.edges_destination_index_definition())?;
+        write_transaction
+          .write_transaction
+          .open_table(graph_info.edges_table_definition())?;
+        write_transaction
+          .write_transaction
+          .open_table(graph_info.edges_source_index_definition())?;
+        write_transaction
+          .write_transaction
+          .open_table(graph_info.edges_destination_index_definition())?;
       }
       else
       {
-        let edge_table = write_transaction.open_table(graph_info.edges_table_definition())?;
+        let edge_table = write_transaction
+          .write_transaction
+          .open_table(graph_info.edges_table_definition())?;
         if edge_table.len()? > 0
         {
           return Err(error::RunTimeError::DeleteConnectedNode.into());
         }
       }
-      write_transaction.delete_table(graph_info.nodes_table_definition())?;
-      write_transaction.open_table(graph_info.nodes_table_definition())?;
+      write_transaction
+        .write_transaction
+        .delete_table(graph_info.nodes_table_definition())?;
+      write_transaction
+        .write_transaction
+        .open_table(graph_info.nodes_table_definition())?;
     }
     else
     {
@@ -1043,6 +1709,46 @@ impl store::Store for Store
           .collect()
       };
 
+      // Call index hooks for nodes that will be deleted
+      let nodes_to_delete = self.select_nodes(
+        transaction,
+        graph_name,
+        super::SelectNodeQuery::select_keys(node_keys.clone()),
+      )?;
+      let registry = &graph_info.index_registry;
+
+      let write_tx = transaction.try_into_write()?;
+      let indexes = registry.iter_indexes();
+      for node in nodes_to_delete.iter()
+      {
+        for idx in indexes.iter()
+        {
+          if let Some(hnsw_idx) = idx.as_any().downcast_ref::<index::HnswVectorIndex>()
+          {
+            let tables = hnsw_store::HnswTableSet::new(graph_name, idx.name());
+            let mut graph_store = hnsw_store::RedbGraphStore::open(write_tx, &tables)?;
+
+            // Get the node ID before deletion
+            if let Some(node_id) = graph_store.node_of(&node.key()).ok().flatten()
+            {
+              // Delete from HNSW graph
+              hnsw_idx
+                .upsert_and_search_ready()
+                .delete(&mut graph_store, &node.key())?;
+
+              // Also delete the vector row
+              let vector_store = hnsw_store::RedbVectorStore::open(
+                write_tx,
+                &tables,
+                hnsw_idx.dimension(),
+                hnsw_idx.encoding(),
+              )?;
+              vector_store.delete(node_id)?;
+            }
+          }
+        }
+      }
+
       if detach
       {
         // Delete the edges connected to the nodes
@@ -1052,17 +1758,19 @@ impl store::Store for Store
           super::SelectEdgeQuery::select_source_keys(super::SelectNodeQuery::select_keys(
             node_keys.clone(),
           )),
-          graph::EdgeDirectivity::Undirected,
+          graphcore::EdgeDirectivity::Undirected,
         )?;
       }
       else
       {
         let write_transaction = transaction.try_into_write()?;
         // Check if the nodes are disconnected
-        let table_source =
-          write_transaction.open_table(graph_info.edges_source_index_definition())?;
-        let table_destination =
-          write_transaction.open_table(graph_info.edges_destination_index_definition())?;
+        let table_source = write_transaction
+          .write_transaction
+          .open_table(graph_info.edges_source_index_definition())?;
+        let table_destination = write_transaction
+          .write_transaction
+          .open_table(graph_info.edges_destination_index_definition())?;
 
         for key in node_keys.iter()
         {
@@ -1081,16 +1789,20 @@ impl store::Store for Store
       }
       let write_transaction = transaction.try_into_write()?;
       // Delete the nodes
-      let mut table_nodes = write_transaction.open_table(graph_info.nodes_table_definition())?;
-      let mut table_source =
-        write_transaction.open_table(graph_info.edges_source_index_definition())?;
-      let mut table_destination =
-        write_transaction.open_table(graph_info.edges_destination_index_definition())?;
-      for key in node_keys.into_iter()
+      let mut table_nodes = write_transaction
+        .write_transaction
+        .open_table(graph_info.nodes_table_definition())?;
+      let mut table_source = write_transaction
+        .write_transaction
+        .open_table(graph_info.edges_source_index_definition())?;
+      let mut table_destination = write_transaction
+        .write_transaction
+        .open_table(graph_info.edges_destination_index_definition())?;
+      for key in node_keys.iter()
       {
-        table_nodes.remove(PersistentKey(key))?;
-        table_source.remove(PersistentKey(key))?;
-        table_destination.remove(PersistentKey(key))?;
+        table_nodes.remove(PersistentKey(key.to_owned()))?;
+        table_source.remove(PersistentKey(key.to_owned()))?;
+        table_destination.remove(PersistentKey(key.to_owned()))?;
       }
     }
     Ok(())
@@ -1110,12 +1822,14 @@ impl store::Store for Store
       store::TransactionBox::Read(read) =>
       {
         let nodes_table = read.open_table(graph_info.nodes_table_definition())?;
-        self.select_nodes_from_table(&nodes_table, &query)
+        self.select_nodes_from_table(graph_name, &nodes_table, &query)
       }
       store::TransactionBox::Write(write) =>
       {
-        let nodes_table = write.open_table(graph_info.nodes_table_definition())?;
-        self.select_nodes_from_table(&nodes_table, &query)
+        let nodes_table = write
+          .write_transaction
+          .open_table(graph_info.nodes_table_definition())?;
+        self.select_nodes_from_table(graph_name, &nodes_table, &query)
       }
     }
   }
@@ -1129,10 +1843,15 @@ impl store::Store for Store
   {
     let transaction = transaction.try_into_write()?;
     let graph_info = self.get_graph_info(graph_name)?;
-    let mut table = transaction.open_table(graph_info.edges_table_definition())?;
-    let mut table_source = transaction.open_table(graph_info.edges_source_index_definition())?;
-    let mut table_destination =
-      transaction.open_table(graph_info.edges_destination_index_definition())?;
+    let mut table = transaction
+      .write_transaction
+      .open_table(graph_info.edges_table_definition())?;
+    let mut table_source = transaction
+      .write_transaction
+      .open_table(graph_info.edges_source_index_definition())?;
+    let mut table_destination = transaction
+      .write_transaction
+      .open_table(graph_info.edges_destination_index_definition())?;
 
     for x in edges_iter
     {
@@ -1171,7 +1890,9 @@ impl store::Store for Store
   {
     let transaction = transaction.try_into_write()?;
     let graph_info = self.get_graph_info(graph_name)?;
-    let mut table = transaction.open_table(graph_info.edges_table_definition())?;
+    let mut table = transaction
+      .write_transaction
+      .open_table(graph_info.edges_table_definition())?;
     let mut pe = table
       .get_required(&edge.key().into(), || InternalError::UnknownEdge)?
       .value();
@@ -1186,7 +1907,7 @@ impl store::Store for Store
     transaction: &mut Self::TransactionBox,
     graph_name: impl AsRef<str>,
     query: super::SelectEdgeQuery,
-    directivity: graph::EdgeDirectivity,
+    directivity: graphcore::EdgeDirectivity,
   ) -> Result<()>
   {
     let graph_name = graph_name.as_ref();
@@ -1195,10 +1916,15 @@ impl store::Store for Store
 
     let transaction = transaction.try_into_write()?;
 
-    let mut table = transaction.open_table(graph_info.edges_table_definition())?;
-    let mut table_source = transaction.open_table(graph_info.edges_source_index_definition())?;
-    let mut table_destination =
-      transaction.open_table(graph_info.edges_destination_index_definition())?;
+    let mut table = transaction
+      .write_transaction
+      .open_table(graph_info.edges_table_definition())?;
+    let mut table_source = transaction
+      .write_transaction
+      .open_table(graph_info.edges_source_index_definition())?;
+    let mut table_destination = transaction
+      .write_transaction
+      .open_table(graph_info.edges_destination_index_definition())?;
 
     for e in edges
     {
@@ -1234,9 +1960,10 @@ impl store::Store for Store
     transaction: &mut Self::TransactionBox,
     graph_name: impl AsRef<str>,
     query: super::SelectEdgeQuery,
-    directivity: graph::EdgeDirectivity,
+    directivity: graphcore::EdgeDirectivity,
   ) -> Result<Vec<super::EdgeResult>>
   {
+    let graph_name = graph_name.as_ref();
     if query.source.is_select_none() || query.destination.is_select_none()
     {
       return Ok(Default::default());
@@ -1258,6 +1985,7 @@ impl store::Store for Store
         ));
 
         self.select_edges_from_tables(
+          graph_name,
           query,
           directivity,
           edges_table,
@@ -1268,17 +1996,26 @@ impl store::Store for Store
       }
       store::TransactionBox::Write(write) =>
       {
-        let edges_table = write.open_table(graph_info.edges_table_definition())?;
-        let nodes_table = write.open_table(graph_info.nodes_table_definition())?;
+        let edges_table = write
+          .write_transaction
+          .open_table(graph_info.edges_table_definition())?;
+        let nodes_table = write
+          .write_transaction
+          .open_table(graph_info.nodes_table_definition())?;
 
         let edges_source_index = Rc::new(RefCell::new(
-          write.open_table(graph_info.edges_source_index_definition())?,
+          write
+            .write_transaction
+            .open_table(graph_info.edges_source_index_definition())?,
         ));
         let edges_destination_index = Rc::new(RefCell::new(
-          write.open_table(graph_info.edges_destination_index_definition())?,
+          write
+            .write_transaction
+            .open_table(graph_info.edges_destination_index_definition())?,
         ));
 
         self.select_edges_from_tables(
+          graph_name,
           query,
           directivity,
           edges_table,
@@ -1290,7 +2027,7 @@ impl store::Store for Store
     }
   }
   fn compute_statistics(&self, transaction: &mut Self::TransactionBox)
-    -> Result<super::Statistics>
+  -> Result<super::Statistics>
   {
     let mut edges_count = 0;
     let mut nodes_count = 0;
@@ -1317,7 +2054,7 @@ impl store::Store for Store
       transaction,
       "default",
       super::SelectEdgeQuery::select_all(),
-      graph::EdgeDirectivity::Directed,
+      graphcore::EdgeDirectivity::Directed,
     )?
     {
       edges_count += 1;
@@ -1337,4 +2074,422 @@ impl store::Store for Store
       properties_count,
     })
   }
+
+  fn create_vector_index(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    spec: super::VectorIndexSpec,
+  ) -> Result<()>
+  {
+    let graph_name_str = graph_name.as_ref();
+    let mut metadata_list = self.get_graph_index_metadata(transaction, graph_name_str)?;
+    if metadata_list.iter().any(|entry| entry.name() == spec.name)
+    {
+      return Err(
+        crate::error::StoreError::DuplicatedVectorIndex {
+          index_name: spec.name.clone(),
+        }
+        .into(),
+      );
+    }
+
+    let metadata = IndexMetadata::VectorIndex {
+      name: spec.name.clone(),
+      label: spec.label.clone(),
+      property: spec.property.clone(),
+      dimension: spec.dimension,
+      metric: spec.metric,
+      hnsw_params: spec.hnsw_params,
+      dtype: spec.dtype.as_str().to_string(),
+    };
+    metadata_list.push(metadata.clone());
+    self.set_graph_index_metadata(transaction, graph_name_str, &metadata_list)?;
+
+    // Create and register the index, then backfill from the current graph nodes.
+    // Always start from scratch — persisted HNSW tables for this (graph, index) pair can only
+    // be stale leftovers (pre-WI 329 orphans, or same-transaction drop+recreate). Backfill uses
+    // the caller's transaction, so nodes created earlier in the same uncommitted transaction are
+    // included correctly.
+    let graph_info = self.get_graph_info(graph_name_str)?;
+    let registry = &graph_info.index_registry;
+    let kind = index::IndexKind::Vector {
+      dimension: spec.dimension,
+      metric: spec.metric,
+      params: spec.hnsw_params,
+    };
+    let idx = index::create_index(kind, &spec.name, spec.property.clone());
+    registry.register_index(spec.name.clone(), idx.clone());
+
+    // Get nodes first, before borrowing transaction for write
+    let nodes = crate::store::Store::select_nodes(
+      self,
+      transaction,
+      graph_name_str,
+      super::SelectNodeQuery::select_all(),
+    )?;
+
+    // Backfill the vector index with existing nodes
+    let tx = transaction.try_into_write()?;
+
+    if let Some(hnsw_idx) = idx.as_any().downcast_ref::<index::HnswVectorIndex>()
+    {
+      let tables = hnsw_store::HnswTableSet::new(graph_name_str, &spec.name);
+      let mut graph_store = hnsw_store::RedbGraphStore::open(tx, &tables)?;
+      let mut vector_store =
+        hnsw_store::RedbVectorStore::open(tx, &tables, hnsw_idx.dimension(), hnsw_idx.encoding())?;
+
+      // Initialize metadata with fresh state
+      let initial_meta = hnsw_store::SimpleMetaBlob {
+        next_node_id: 0,
+        entry_point: None,
+        max_level: -1,
+      };
+      graph_store.write_meta(&initial_meta)?;
+
+      let hnsw = hnsw_idx.upsert_and_search_ready();
+
+      // Backfill: insert each node's vector
+      for node in nodes
+      {
+        if let Some(prop_key) = spec.property.as_ref()
+          && let Some(prop_value) = node.properties().get(prop_key)
+          && let Some(floats) = crate::store::vector_extract::extract_f32_vec(prop_value)
+          && floats.len() == spec.dimension
+        {
+          hnsw.set(
+            &mut graph_store,
+            &mut vector_store,
+            node.key(),
+            floats.as_slice(),
+          )?;
+        }
+      }
+    }
+
+    Ok(())
+  }
+
+  fn list_vector_indexes(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+  ) -> Result<Vec<super::VectorIndexSpec>>
+  {
+    let graph_name = graph_name.as_ref();
+    let mut specs = Vec::new();
+    let metadata_list = self.get_graph_index_metadata(transaction, graph_name)?;
+    for metadata in metadata_list
+    {
+      let IndexMetadata::VectorIndex {
+        name,
+        label,
+        property,
+        dimension,
+        metric,
+        hnsw_params,
+        dtype,
+      } = metadata;
+      specs.push(super::VectorIndexSpec {
+        name,
+        label,
+        property,
+        dimension,
+        metric,
+        hnsw_params,
+        dtype: graphcore::DType::from_name(&dtype).unwrap_or(graphcore::DType::F32),
+      });
+    }
+
+    Ok(specs)
+  }
+
+  fn drop_vector_index(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    index_name: impl AsRef<str>,
+  ) -> Result<()>
+  {
+    self.drop_index(transaction, graph_name.as_ref(), index_name.as_ref())
+  }
+
+  fn upsert_vector(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    index_name: impl AsRef<str>,
+    node_id: graph::Key,
+    tensor: &value::Tensor,
+  ) -> Result<()>
+  {
+    let graph_name = graph_name.as_ref();
+    let index_name = index_name.as_ref();
+    let tx = transaction.try_into_write()?;
+    let graph_info = self.get_graph_info(graph_name)?;
+    let registry = &graph_info.index_registry;
+
+    for index in registry.iter_indexes()
+    {
+      if index.as_any().is::<index::HnswVectorIndex>()
+        && index.name() == index_name
+        && let Some(hnsw_idx) = index.as_any().downcast_ref::<index::HnswVectorIndex>()
+      {
+        if tensor.numel() != hnsw_idx.dimension()
+        {
+          return Err(
+            StoreError::InvalidFormat(format!(
+              "vector dimension {} does not match index dimension {}",
+              tensor.numel(),
+              hnsw_idx.dimension()
+            ))
+            .into(),
+          );
+        }
+
+        // Convert tensor to f32 slice
+        let floats = match tensor.dtype()
+        {
+          value::DType::F32 => match tensor.as_f32_slice()
+          {
+            Some(s) => s.to_vec(),
+            None => tensor.to_f32_vec(),
+          },
+          value::DType::F64 => tensor.to_f32_vec(),
+          other =>
+          {
+            return Err(
+              StoreError::InvalidFormat(format!(
+                "dtype {:?} cannot be cast to f32 for HNSW indexing",
+                other
+              ))
+              .into(),
+            );
+          }
+        };
+
+        // Open stores and perform immediate upsert
+        let tables = hnsw_store::HnswTableSet::new(graph_name, index_name);
+        let mut graph_store = hnsw_store::RedbGraphStore::open(tx, &tables)?;
+        let mut vector_store = hnsw_store::RedbVectorStore::open(
+          tx,
+          &tables,
+          hnsw_idx.dimension(),
+          hnsw_idx.encoding(),
+        )?;
+
+        hnsw_idx.upsert_and_search_ready().set(
+          &mut graph_store,
+          &mut vector_store,
+          node_id,
+          floats.as_slice(),
+        )?;
+
+        return Ok(());
+      }
+    }
+
+    Err(StoreError::InvalidFormat(format!("vector index '{}' does not exist", index_name)).into())
+  }
+
+  fn vector_search(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    index_name: impl AsRef<str>,
+    query: &value::Tensor,
+    k: usize,
+  ) -> Result<Vec<super::VectorSearchResult>>
+  {
+    if k == 0
+    {
+      return Ok(Vec::new());
+    }
+
+    let f32_query: std::borrow::Cow<[f32]> = match query.dtype()
+    {
+      value::DType::F32 => match query.as_f32_slice()
+      {
+        Some(s) => std::borrow::Cow::Borrowed(s),
+        None => std::borrow::Cow::Owned(query.to_f32_vec()),
+      },
+      value::DType::F64 => std::borrow::Cow::Owned(query.to_f32_vec()),
+      other =>
+      {
+        return Err(
+          StoreError::InvalidFormat(format!(
+            "vector search only accepts F32 or F64 tensors; got {:?}",
+            other
+          ))
+          .into(),
+        );
+      }
+    };
+
+    let graph_name = graph_name.as_ref();
+    let index_name = index_name.as_ref();
+    let graph_info = self.get_graph_info(graph_name)?;
+    let registry = &graph_info.index_registry;
+
+    if let Some(index) = registry.get_index(index_name)
+      && let Some(hnsw_idx) = index.as_any().downcast_ref::<index::HnswVectorIndex>()
+    {
+      if f32_query.len() != hnsw_idx.dimension()
+      {
+        return Err(
+          StoreError::InvalidFormat(format!(
+            "Vector dimension {} does not match index dimension {}",
+            f32_query.len(),
+            hnsw_idx.dimension()
+          ))
+          .into(),
+        );
+      }
+
+      // Open stores from appropriate transaction type
+      let tables = hnsw_store::HnswTableSet::new(graph_name, index_name);
+      let ef_search = hnsw_idx.ef_search();
+      let mut results = match transaction
+      {
+        TransactionBox::Write(tx) =>
+        {
+          let graph_store = hnsw_store::RedbGraphStore::open(tx, &tables)?;
+          let vector_store = hnsw_store::RedbVectorStore::open(
+            tx,
+            &tables,
+            hnsw_idx.dimension(),
+            hnsw_idx.encoding(),
+          )?;
+          match hnsw_idx.upsert_and_search_ready().search(
+            &graph_store,
+            &vector_store,
+            &f32_query,
+            k,
+            Some(ef_search),
+            None,
+          )
+          {
+            Ok(results) => results,
+            Err(db_index::hnsw::Error::EmptyIndex) => vec![],
+            Err(e) =>
+            {
+              return Err(StoreError::InvalidFormat(format!("HNSW search failed: {:?}", e)).into());
+            }
+          }
+        }
+        TransactionBox::Read(read_tx) =>
+        {
+          // For read transactions, use read-only stores
+          if let Some(graph_store) = hnsw_store::RedbGraphStoreRead::open(read_tx, &tables)?
+          {
+            if let Some(vector_store) = hnsw_store::RedbVectorStoreRead::open(
+              read_tx,
+              &tables,
+              hnsw_idx.dimension(),
+              hnsw_idx.encoding(),
+            )?
+            {
+              match hnsw_idx.upsert_and_search_ready().search(
+                &graph_store,
+                &vector_store,
+                &f32_query,
+                k,
+                Some(ef_search),
+                None,
+              )
+              {
+                Ok(results) => results,
+                Err(db_index::hnsw::Error::EmptyIndex) => vec![],
+                Err(e) =>
+                {
+                  return Err(
+                    StoreError::InvalidFormat(format!("HNSW search failed: {:?}", e)).into(),
+                  );
+                }
+              }
+            }
+            else
+            {
+              vec![]
+            }
+          }
+          else
+          {
+            vec![]
+          }
+        }
+      };
+
+      const EPSILON: f32 = 1e-6;
+      let sequences = self.node_sequences.lock().unwrap();
+
+      results.sort_by(|a, b| {
+        let distance_diff = (a.distance - b.distance).abs();
+        if distance_diff < EPSILON
+        {
+          let seq_a = sequences.get(&a.key).copied().unwrap_or(u64::MAX);
+          let seq_b = sequences.get(&b.key).copied().unwrap_or(u64::MAX);
+          seq_a.cmp(&seq_b)
+        }
+        else
+        {
+          a.distance
+            .partial_cmp(&b.distance)
+            .unwrap_or(std::cmp::Ordering::Equal)
+        }
+      });
+
+      results.truncate(k);
+      let vector_results = results
+        .into_iter()
+        .map(|hit| crate::store::VectorSearchResult {
+          node_id: hit.key,
+          score: hit.distance,
+        })
+        .collect();
+      return Ok(vector_results);
+    }
+
+    Err(InternalError::Unimplemented("Vector index not found").into())
+  }
+
+  fn apply_vector_indices_for_node(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    node: &crate::graph::Node,
+  ) -> Result<()>
+  {
+    let graph_name = graph_name.as_ref();
+    let graph_info = self.get_graph_info(graph_name)?;
+    let metadata_list = self.get_graph_index_metadata(transaction, graph_name)?;
+    let registry = &graph_info.index_registry;
+
+    for metadata in metadata_list.iter()
+    {
+      if let IndexMetadata::VectorIndex {
+        name,
+        label,
+        property,
+        dimension,
+        ..
+      } = metadata
+        && let (Some(idx_label), Some(idx_property)) = (label.as_deref(), property.as_deref())
+        && node
+          .labels()
+          .iter()
+          .any(|node_label| node_label == idx_label)
+        && let Some(index) = registry.get_index(name)
+        && index.as_any().is::<index::HnswVectorIndex>()
+        && let Some(prop_val) = node.properties().get(idx_property)
+        && let Some(vector) = crate::store::vector_extract::extract_f32_vec(prop_val)
+        && vector.len() == *dimension
+      {
+        let tensor = value::Tensor::from_f32_slice(&vector);
+        self.upsert_vector(transaction, graph_name, name, node.key(), &tensor)?;
+      }
+    }
+
+    Ok(())
+  }
 }