diff --git a/Cargo.lock b/Cargo.lock
index bc6a6d7..85ca93d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -130,7 +130,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -141,7 +141,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -176,9 +176,9 @@ checksum = "f02882884d3e1bc524fb12c79f107f6ad0e1cfd498c536ffb494301740995dfe"
 
 [[package]]
 name = "arrow"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bd47f2a6ddc39244bd722a27ee5da66c03369d087b9e024eafdb03e98b98ea7"
+checksum = "7c14b3d39f306bc28fd639d59f06e17a0f377d0021e1b7e9054e4d6fedc98774"
 dependencies = [
  "arrow-arith",
  "arrow-array",
@@ -197,9 +197,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-arith"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c7bbd679c5418b8639b92be01f361d60013c4906574b578b77b63c78356594c"
+checksum = "ce2961626677665b2195eb59242af4c7befe7b8737ca2050295389362380104e"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -211,9 +211,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-array"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8a4ab47b3f3eac60f7fd31b81e9028fda018607bcc63451aca4f2b755269862"
+checksum = "1e5f6adeffdf587d7a31db5d2266189624b526730cd3627f9ff9fedae97ad584"
 dependencies = [
  "ahash",
  "arrow-buffer",
@@ -221,7 +221,7 @@ dependencies = [
  "arrow-schema",
  "chrono",
  "half",
- "hashbrown 0.16.1",
+ "hashbrown 0.17.1",
  "num-complex",
  "num-integer",
  "num-traits",
@@ -229,21 +229,21 @@ dependencies = [
 
 [[package]]
 name = "arrow-buffer"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d18b89b4c4f4811d0858175e79541fe98e33e18db3b011708bc287b1240593f"
+checksum = "097d193003ce7995d5d087089069ec2a6e0187faf5a6f8c9f38af2645d987182"
 dependencies = [
  "bytes",
  "half",
- "num-bigint",
+ "num-bigint 0.5.1",
  "num-traits",
 ]
 
 [[package]]
 name = "arrow-cast"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "722b5c41dd1d14d0a879a1bce92c6fe33f546101bb2acce57a209825edd075b3"
+checksum = "635c9c635668ad26adf76cce8fb276c4be7cf06e63bd516de7da514f9680ee53"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -252,7 +252,7 @@ dependencies = [
  "arrow-schema",
  "arrow-select",
  "atoi",
- "base64 0.22.1",
+ "base64 0.23.1",
  "chrono",
  "half",
  "lexical-core",
@@ -262,9 +262,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-csv"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27ddb80a4848e03b1655af496d5ac2563a779e5742fcb48f2ca2e089c9cd2197"
+checksum = "4c2ebf8d631e79b02c16cf5ae860561272c26024ec88fce389a56aaddd558e86"
 dependencies = [
  "arrow-array",
  "arrow-cast",
@@ -277,9 +277,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-data"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1683705c63dcf0d18972759eda48489028cbbff67af7d6bef2c6b7b74ab778a"
+checksum = "9ba2f832eaeca24b8f26143dba750e42ee4ab51cf7d65e701ca9607cfda9f358"
 dependencies = [
  "arrow-buffer",
  "arrow-schema",
@@ -290,9 +290,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-ipc"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cf72d04c07229fbf4dbebe7145cac37d7cf7ec582fe705c6b92cb314af096ab"
+checksum = "dcc41681ea80f521df14c36725b74d4c60702c47f0793af2be469c04527e2599"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -304,15 +304,16 @@ dependencies = [
 
 [[package]]
 name = "arrow-json"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a84a905f41fedfcd7679813c89a61dc369c0f932b27aa8dcc6aa051cc781a97d"
+checksum = "a2f57d7a81969f24ccf80809587b76c09897e6f829d2d65a5976bfb3218851f1"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
  "arrow-cast",
- "arrow-data",
+ "arrow-ord",
  "arrow-schema",
+ "arrow-select",
  "chrono",
  "half",
  "indexmap",
@@ -328,9 +329,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-ord"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "082342947d4e5a2bcccf029a0a0397e21cb3bb8421edd9571d34fb5dd2670256"
+checksum = "2c900759f3bd8354fd4196bc4403eee846894dc2adf66b4225472006a0bf18c5"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -341,9 +342,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-row"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3a931b520a2a5e22033e01a6f2486b4cdc26f9106b759abeebc320f125e94d7"
+checksum = "f4c6425032e28266e3fc4ff680805e57e670d6ea92473043f3e65b7ed6ac79f2"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -354,15 +355,15 @@ dependencies = [
 
 [[package]]
 name = "arrow-schema"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4cf0d4a6609679e03002167a61074a21d7b1ad9ea65e462b2c0a97f8a3b2bc6"
+checksum = "10fab8d4563491417ba801fab29d205104d20d4bdf37bda6cd1cf425cff598cd"
 
 [[package]]
 name = "arrow-select"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b320d86a9806923663bb0fd9baa65ecaba81cb0cd77ff8c1768b9716b4ef891"
+checksum = "fc58569193c2525915f3cc6310edba3792f1200f65d6e9ed330aa33e691493b8"
 dependencies = [
  "ahash",
  "arrow-array",
@@ -374,9 +375,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-string"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b493e99162e5764077e7823e50ba284858d365922631c7aaefe9487b1abd02c2"
+checksum = "2e0813f3c35c1cfea65e14c20a953440f7783c088b7ad2d0db162ccdeefcec14"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -507,6 +508,12 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
+[[package]]
+name = "base64"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
+
 [[package]]
 name = "base64ct"
 version = "1.8.3"
@@ -519,7 +526,7 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a6773ddc0eafc0e509fb60e48dff7f450f8e674a0686ae8605e8d9901bd5eefa"
 dependencies = [
- "num-bigint",
+ "num-bigint 0.4.6",
  "num-integer",
  "num-traits",
  "serde",
@@ -1020,9 +1027,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.18"
+version = "0.9.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f"
 dependencies = [
  "crossbeam-utils",
 ]
@@ -1257,7 +1264,7 @@ dependencies = [
  "libc",
  "option-ext",
  "redox_users",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1365,7 +1372,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1847,9 +1854,9 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.4.15"
+version = "0.4.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6cb093c84e8bd9b188d4c4a8cb6579fc016968d14c99882163cd3ff402a4f155"
+checksum = "a9f37a958b41b3b19ee2707c06439c0e9e547e847223eb791ecb0cb821c65e27"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -2281,12 +2288,6 @@ dependencies = [
  "web-time",
 ]
 
-[[package]]
-name = "integer-encoding"
-version = "3.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bb03732005da905c88227371639bf1ad885cc712789c011c31c5fb3ab3ccf02"
-
 [[package]]
 name = "ipnet"
 version = "2.12.0"
@@ -2555,18 +2556,18 @@ checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
 
 [[package]]
 name = "lz4_flex"
-version = "0.12.2"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90071f8077f8e40adfc4b7fe9cd495ce316263f19e75c2211eeff3fdf475a3d9"
+checksum = "7ef0d4ed8669f8f8826eb00dc878084aa8f253506c4fd5e8f58f5bce72ddb97e"
 dependencies = [
  "twox-hash",
 ]
 
 [[package]]
 name = "lz4_flex"
-version = "0.13.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ef0d4ed8669f8f8826eb00dc878084aa8f253506c4fd5e8f58f5bce72ddb97e"
+checksum = "ecbdfe44b1bd960b68170b417450a628c43f7cf56bb3c5317e61cb230ee7f226"
 dependencies = [
  "twox-hash",
 ]
@@ -2855,7 +2856,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -2868,6 +2869,16 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-bigint"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93e7820bc0a80a0238e650327316f929ba18d5be054b647490a3a6a339f3e7c0"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-complex"
 version = "0.4.6"
@@ -3011,15 +3022,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
-[[package]]
-name = "ordered-float"
-version = "2.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "ordered-float"
 version = "5.3.0"
@@ -3090,34 +3092,31 @@ dependencies = [
 
 [[package]]
 name = "parquet"
-version = "57.3.1"
+version = "59.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e832c6aa20310fc6de7ea5a3f4e20d34fd83e3b43229d32b81ffe5c14d74692"
+checksum = "ff322f54b1a0f9288e614ed1f2d329b380af5476420db19f46ffb865e1163d73"
 dependencies = [
  "ahash",
  "arrow-array",
  "arrow-buffer",
- "arrow-cast",
  "arrow-data",
  "arrow-ipc",
  "arrow-schema",
  "arrow-select",
- "base64 0.22.1",
+ "base64 0.23.1",
  "brotli",
  "bytes",
  "chrono",
  "flate2",
  "half",
- "hashbrown 0.16.1",
- "lz4_flex 0.12.2",
- "num-bigint",
+ "hashbrown 0.17.1",
+ "lz4_flex 0.14.0",
+ "num-bigint 0.5.1",
  "num-integer",
  "num-traits",
- "paste",
  "seq-macro",
  "simdutf8",
  "snap",
- "thrift",
  "twox-hash",
  "zstd",
 ]
@@ -3565,9 +3564,9 @@ dependencies = [
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.14"
+version = "0.11.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
+checksum = "4fcb935c5bec503c2f0e306bdd3e58bb9029dcb14fa8d9ac76e3a5256ac0763e"
 dependencies = [
  "bytes",
  "getrandom 0.3.4",
@@ -3911,7 +3910,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4226,7 +4225,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52d1cfed4120b4d927bf7c0f86d2087a4a7d6027c906d9f9d525a80573b9be51"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -4378,7 +4377,7 @@ dependencies = [
  "getrandom 0.4.3",
  "once_cell",
  "rustix 1.1.4",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4439,17 +4438,6 @@ dependencies = [
  "cfg-if",
 ]
 
-[[package]]
-name = "thrift"
-version = "0.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e54bc85fc7faa8bc175c4bab5b92ba8d9a3ce893d0e9f42cc455c8ab16a9e09"
-dependencies = [
- "byteorder",
- "integer-encoding",
- "ordered-float 2.10.1",
-]
-
 [[package]]
 name = "tiny-keccak"
 version = "2.0.2"
@@ -5019,7 +5007,7 @@ dependencies = [
  "memmap2",
  "metal",
  "ndarray 0.16.1",
- "ordered-float 5.3.0",
+ "ordered-float",
  "ort",
  "parquet",
  "pollster",
@@ -5343,7 +5331,7 @@ dependencies = [
  "ndk-sys",
  "objc",
  "once_cell",
- "ordered-float 5.3.0",
+ "ordered-float",
  "parking_lot",
  "portable-atomic",
  "portable-atomic-util",
@@ -5401,7 +5389,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index c5f69b9..4075694 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -58,8 +58,8 @@ serde-wasm-bindgen = { version = "0.6", optional = true }
 js-sys = { version = "0.3", optional = true }
 web-sys = { version = "0.3", optional = true, features = ["console", "Window", "Storage", "IdbFactory", "IdbDatabase", "IdbObjectStore", "IdbTransaction"] }
 console_error_panic_hook = { version = "0.1", optional = true }
-parquet = { version = "57", optional = true }
-arrow = { version = "57", optional = true }
+parquet = { version = "59", optional = true }
+arrow = { version = "59", optional = true }
 candle-core = { version = "0.9", optional = true }
 candle-nn = { version = "0.9", optional = true }
 candle-transformers = { version = "0.9", optional = true }
diff --git a/benches/openai_embeddings_bench.rs b/benches/openai_embeddings_bench.rs
index 12527db..ec69684 100644
--- a/benches/openai_embeddings_bench.rs
+++ b/benches/openai_embeddings_bench.rs
@@ -6,7 +6,7 @@
 //
 // Run with: cargo bench --features "embeddings,openai-embeddings" --bench openai_embeddings_bench
 
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main};
 use vecstore::embeddings::openai_backend::{OpenAIEmbedding, OpenAIModel};
 
 // Helper to create embedder
diff --git a/benches/rag_benchmarks.rs b/benches/rag_benchmarks.rs
index cf79bb0..9df80d2 100644
--- a/benches/rag_benchmarks.rs
+++ b/benches/rag_benchmarks.rs
@@ -1,9 +1,9 @@
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main};
 use std::collections::HashMap;
 use vecstore::{
+    Metadata, Query, VecStore,
     rag_utils::MultiQueryRetrieval,
     text_splitter::{RecursiveCharacterTextSplitter, TextSplitter},
-    Metadata, Query, VecStore,
 };
 
 // Mock embedding function for benchmarks
diff --git a/benches/simd_bench.rs b/benches/simd_bench.rs
index cdbb5ad..af52421 100644
--- a/benches/simd_bench.rs
+++ b/benches/simd_bench.rs
@@ -1,4 +1,4 @@
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main};
 use vecstore::simd::*;
 
 fn generate_random_vector(dim: usize) -> Vec<f32> {
diff --git a/benches/vecstore_bench.rs b/benches/vecstore_bench.rs
index 3ad4d4f..f6b8266 100644
--- a/benches/vecstore_bench.rs
+++ b/benches/vecstore_bench.rs
@@ -1,6 +1,6 @@
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main};
 use std::collections::HashMap;
-use vecstore::{make_record, FilterExpr, FilterOp, Metadata, Query, VecStore};
+use vecstore::{FilterExpr, FilterOp, Metadata, Query, VecStore, make_record};
 
 fn setup_store_with_data(n: usize, dim: usize) -> (tempfile::TempDir, VecStore) {
     let temp_dir = tempfile::tempdir().unwrap();
diff --git a/benches/wasm_hnsw_bench.rs b/benches/wasm_hnsw_bench.rs
index 44de542..ccdf80d 100644
--- a/benches/wasm_hnsw_bench.rs
+++ b/benches/wasm_hnsw_bench.rs
@@ -5,15 +5,15 @@
 //
 // Run with: cargo bench --bench wasm_hnsw_bench
 
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main};
 use rand::Rng;
-use vecstore::store::wasm_hnsw::WasmHnsw;
 use vecstore::Distance;
+use vecstore::store::wasm_hnsw::WasmHnsw;
 
 fn generate_random_vectors(n: usize, dim: usize) -> Vec<Vec<f32>> {
     let mut rng = rand::thread_rng();
     (0..n)
-        .map(|_| (0..dim).map(|_| rng.gen::<f32>()).collect())
+        .map(|_| (0..dim).map(|_| rng.r#gen::<f32>()).collect())
         .collect()
 }
 
diff --git a/examples/01_basic_rag.rs b/examples/01_basic_rag.rs
index 165d88d..6f6f145 100644
--- a/examples/01_basic_rag.rs
+++ b/examples/01_basic_rag.rs
@@ -12,8 +12,8 @@
 use anyhow::Result;
 use std::collections::HashMap;
 use vecstore::{
-    text_splitter::{RecursiveCharacterTextSplitter, TextSplitter},
     Metadata, Query, VecStore,
+    text_splitter::{RecursiveCharacterTextSplitter, TextSplitter},
 };
 
 fn main() -> Result<()> {
diff --git a/examples/03_web_scraping_rag.rs b/examples/03_web_scraping_rag.rs
index 915f227..fb0e0de 100644
--- a/examples/03_web_scraping_rag.rs
+++ b/examples/03_web_scraping_rag.rs
@@ -11,8 +11,8 @@
 use anyhow::Result;
 use std::collections::HashMap;
 use vecstore::{
-    text_splitter::{RecursiveCharacterTextSplitter, TextSplitter},
     Metadata, Query, VecStore,
+    text_splitter::{RecursiveCharacterTextSplitter, TextSplitter},
 };
 
 fn main() -> Result<()> {
diff --git a/examples/04_code_search.rs b/examples/04_code_search.rs
index 99c4dd4..5529001 100644
--- a/examples/04_code_search.rs
+++ b/examples/04_code_search.rs
@@ -10,8 +10,8 @@
 use anyhow::Result;
 use std::collections::HashMap;
 use vecstore::{
-    text_splitter::{CodeTextSplitter, TextSplitter},
     Metadata, Query, VecStore,
+    text_splitter::{CodeTextSplitter, TextSplitter},
 };
 
 fn main() -> Result<()> {
diff --git a/examples/06_reranking_pipeline.rs b/examples/06_reranking_pipeline.rs
index ad71ded..d7f335a 100644
--- a/examples/06_reranking_pipeline.rs
+++ b/examples/06_reranking_pipeline.rs
@@ -11,8 +11,8 @@
 use anyhow::Result;
 use std::collections::HashMap;
 use vecstore::{
-    text_splitter::{RecursiveCharacterTextSplitter, TextSplitter},
     Metadata, Neighbor, Query, VecStore,
+    text_splitter::{RecursiveCharacterTextSplitter, TextSplitter},
 };
 
 fn main() -> Result<()> {
diff --git a/examples/07_multi_query_rag.rs b/examples/07_multi_query_rag.rs
index b6410df..8c0185e 100644
--- a/examples/07_multi_query_rag.rs
+++ b/examples/07_multi_query_rag.rs
@@ -10,9 +10,9 @@
 use anyhow::Result;
 use std::collections::HashMap;
 use vecstore::{
+    Metadata, Query, VecStore,
     rag_utils::MultiQueryRetrieval,
     text_splitter::{RecursiveCharacterTextSplitter, TextSplitter},
-    Metadata, Query, VecStore,
 };
 
 fn main() -> Result<()> {
diff --git a/examples/08_conversation_rag.rs b/examples/08_conversation_rag.rs
index 4ff903d..0cd9d28 100644
--- a/examples/08_conversation_rag.rs
+++ b/examples/08_conversation_rag.rs
@@ -8,9 +8,9 @@
 use anyhow::Result;
 use std::collections::HashMap;
 use vecstore::{
+    Metadata, Query, VecStore,
     rag_utils::ConversationMemory,
     text_splitter::{RecursiveCharacterTextSplitter, TextSplitter},
-    Metadata, Query, VecStore,
 };
 
 fn main() -> Result<()> {
diff --git a/examples/09_evaluation_demo.rs b/examples/09_evaluation_demo.rs
index 263adae..eb024f5 100644
--- a/examples/09_evaluation_demo.rs
+++ b/examples/09_evaluation_demo.rs
@@ -9,8 +9,8 @@
 use anyhow::Result;
 use std::collections::HashMap;
 use vecstore::{
-    text_splitter::{RecursiveCharacterTextSplitter, TextSplitter},
     Metadata, Query, VecStore,
+    text_splitter::{RecursiveCharacterTextSplitter, TextSplitter},
 };
 
 fn main() -> Result<()> {
@@ -50,7 +50,10 @@ fn main() -> Result<()> {
             "What is VecStore?",
             "VecStore is a high-performance vector database built in Rust.",
         ),
-        ("How fast is VecStore?", "Rust avoids the Python interpreter in tight loops."),
+        (
+            "How fast is VecStore?",
+            "Rust avoids the Python interpreter in tight loops.",
+        ),
     ];
 
     let mut total_score = 0.0;
diff --git a/examples/10_production_rag.rs b/examples/10_production_rag.rs
index 6a03777..37007a4 100644
--- a/examples/10_production_rag.rs
+++ b/examples/10_production_rag.rs
@@ -12,8 +12,8 @@ use anyhow::{Context, Result};
 use std::collections::HashMap;
 use std::time::Instant;
 use vecstore::{
-    text_splitter::{RecursiveCharacterTextSplitter, TextSplitter},
     Metadata, Query, VecDatabase,
+    text_splitter::{RecursiveCharacterTextSplitter, TextSplitter},
 };
 
 fn main() -> Result<()> {
diff --git a/examples/bulk_migration_demo.rs b/examples/bulk_migration_demo.rs
index 5adc6b2..aef7c6d 100644
--- a/examples/bulk_migration_demo.rs
+++ b/examples/bulk_migration_demo.rs
@@ -10,8 +10,8 @@
 use anyhow::Result;
 use std::fs;
 use tempfile::TempDir;
-use vecstore::bulk_migration::{ChromaDBMigration, MigrationConfig, PineconeMigration};
 use vecstore::VecStore;
+use vecstore::bulk_migration::{ChromaDBMigration, MigrationConfig, PineconeMigration};
 
 fn main() -> Result<()> {
     println!("🔄 VecStore Bulk Migration Demo\n");
diff --git a/examples/compression.rs b/examples/compression.rs
index c2c63af..7f26e4d 100644
--- a/examples/compression.rs
+++ b/examples/compression.rs
@@ -17,8 +17,8 @@
 //! ```
 
 use vecstore::compression::{
-    decode_rle, encode_rle, encode_varint, CompressedNeighborList,
-    CompressionConfig, CompressionLevel, CompressionStats,
+    CompressedNeighborList, CompressionConfig, CompressionLevel, CompressionStats, decode_rle,
+    encode_rle, encode_varint,
 };
 
 fn main() {
diff --git a/examples/dim_reduction_demo.rs b/examples/dim_reduction_demo.rs
index b7699f2..3eb74c0 100644
--- a/examples/dim_reduction_demo.rs
+++ b/examples/dim_reduction_demo.rs
@@ -7,7 +7,7 @@
 //! - Reconstruct original vectors
 
 use anyhow::Result;
-use vecstore::dim_reduction::{ReductionStats, PCA};
+use vecstore::dim_reduction::{PCA, ReductionStats};
 
 fn generate_high_dim_data() -> Vec<Vec<f32>> {
     let mut vectors = Vec::new();
diff --git a/examples/distance_metrics_demo.rs b/examples/distance_metrics_demo.rs
index 6f25976..175d184 100644
--- a/examples/distance_metrics_demo.rs
+++ b/examples/distance_metrics_demo.rs
@@ -12,8 +12,8 @@
 
 use std::collections::HashMap;
 use vecstore::{
-    hamming_distance_simd, jaccard_distance_simd, manhattan_distance_simd, Distance, Metadata,
-    VecStore,
+    Distance, Metadata, VecStore, hamming_distance_simd, jaccard_distance_simd,
+    manhattan_distance_simd,
 };
 
 fn main() -> anyhow::Result<()> {
diff --git a/examples/distributed_indexing.rs b/examples/distributed_indexing.rs
index f83e254..7c7ad08 100644
--- a/examples/distributed_indexing.rs
+++ b/examples/distributed_indexing.rs
@@ -23,8 +23,8 @@
 //! ```
 
 use vecstore::distributed::{
-    ConsistencyLevel, ConsistentHashRing, DistributedConfig, DistributedStore,
-    ReplicationStrategy, ShardingStrategy,
+    ConsistencyLevel, ConsistentHashRing, DistributedConfig, DistributedStore, ReplicationStrategy,
+    ShardingStrategy,
 };
 
 fn main() {
diff --git a/examples/embedding_integration_demo.rs b/examples/embedding_integration_demo.rs
index 12c5331..507d3db 100644
--- a/examples/embedding_integration_demo.rs
+++ b/examples/embedding_integration_demo.rs
@@ -17,8 +17,8 @@
 
 #[cfg(feature = "embeddings")]
 use vecstore::{
-    embeddings::{EmbeddingCollection, SimpleEmbedder, TextEmbedder},
     Metadata, VecDatabase,
+    embeddings::{EmbeddingCollection, SimpleEmbedder, TextEmbedder},
 };
 
 #[cfg(feature = "embeddings")]
diff --git a/examples/fuzzy_search.rs b/examples/fuzzy_search.rs
index 09d2aff..883e4fa 100644
--- a/examples/fuzzy_search.rs
+++ b/examples/fuzzy_search.rs
@@ -18,8 +18,8 @@
 //! ```
 
 use vecstore::fuzzy::{
-    damerau_levenshtein_distance, levenshtein_distance, similarity_score, suggest_corrections,
-    BKTree, FuzzyMatcher,
+    BKTree, FuzzyMatcher, damerau_levenshtein_distance, levenshtein_distance, similarity_score,
+    suggest_corrections,
 };
 
 fn main() {
diff --git a/examples/gpu_acceleration.rs b/examples/gpu_acceleration.rs
index caf4a24..4cd7e84 100644
--- a/examples/gpu_acceleration.rs
+++ b/examples/gpu_acceleration.rs
@@ -294,10 +294,10 @@ fn main() {
                 };
 
                 println!("{:<20}  {:>12.2}  {:>14.2}x", name, duration_ms, speedup);
-            }
+            },
             Err(_) => {
                 println!("{:<20}  {:>12}  {:>15}", name, "N/A", "N/A");
-            }
+            },
         }
     }
 
diff --git a/examples/graph_visualization.rs b/examples/graph_visualization.rs
index b2fdd0b..7b90e80 100644
--- a/examples/graph_visualization.rs
+++ b/examples/graph_visualization.rs
@@ -143,14 +143,14 @@ fn main() -> Result<()> {
             println!("   2. Open graph.json in a D3.js visualization tool");
             println!("   3. Load graph_cytoscape.json in Cytoscape.js");
             println!("   4. Read graph_stats.txt for detailed metrics");
-        }
+        },
         Err(e) => {
             println!("⚠️  Graph visualization not available: {}", e);
             println!("\nNote: Graph visualization is currently only supported for WASM builds.");
             println!("To use visualization:");
             println!("  1. Build with: cargo build --target wasm32-unknown-unknown");
             println!("  2. Or use the WASM-based backend");
-        }
+        },
     }
 
     Ok(())
diff --git a/examples/langchain_rag_pipeline.rs b/examples/langchain_rag_pipeline.rs
index 8dcdc08..53c1468 100644
--- a/examples/langchain_rag_pipeline.rs
+++ b/examples/langchain_rag_pipeline.rs
@@ -11,8 +11,8 @@
 use anyhow::Result;
 use vecstore::error::VecStoreError;
 use vecstore::{
-    print_health_report, Document, HealthChecker, LangChainVectorStore, RetrieverConfig, VecStore,
-    VectorStoreRetriever,
+    Document, HealthChecker, LangChainVectorStore, RetrieverConfig, VecStore, VectorStoreRetriever,
+    print_health_report,
 };
 
 fn main() -> Result<()> {
diff --git a/examples/metadata_indexing_demo.rs b/examples/metadata_indexing_demo.rs
index 65efdd7..c8e6ff9 100644
--- a/examples/metadata_indexing_demo.rs
+++ b/examples/metadata_indexing_demo.rs
@@ -183,7 +183,9 @@ fn main() -> Result<()> {
     println!("   • Range queries: O(log N) instead of O(N)");
     println!("   • Equality queries: O(1) instead of O(N)");
     println!("   • Compound queries: Fast intersection of index results");
-    println!("   • Potential speedup: orders of magnitude for large datasets (measure on your workload)");
+    println!(
+        "   • Potential speedup: orders of magnitude for large datasets (measure on your workload)"
+    );
 
     println!("\n📝 Use Cases:");
     println!("   • E-commerce: Filter by price, category, rating");
diff --git a/examples/namespace_demo.rs b/examples/namespace_demo.rs
index ada1582..a55319f 100644
--- a/examples/namespace_demo.rs
+++ b/examples/namespace_demo.rs
@@ -201,7 +201,7 @@ fn main() -> anyhow::Result<()> {
     match result {
         Err(e) if e.to_string().contains("not active") => {
             println!("   ✅ Write rejected: {}", e);
-        }
+        },
         _ => println!("   ⚠️  Expected error but got: {:?}", result),
     }
 
diff --git a/examples/openai_basic.rs b/examples/openai_basic.rs
index d479c7e..b323035 100644
--- a/examples/openai_basic.rs
+++ b/examples/openai_basic.rs
@@ -34,7 +34,7 @@ async fn main() -> Result<()> {
             eprintln!("\nPlease set your OpenAI API key:");
             eprintln!("  export OPENAI_API_KEY='your-api-key-here'\n");
             std::process::exit(1);
-        }
+        },
     };
 
     println!("✓ API key found\n");
diff --git a/examples/openai_cost_tracking.rs b/examples/openai_cost_tracking.rs
index 634e332..1d46ab7 100644
--- a/examples/openai_cost_tracking.rs
+++ b/examples/openai_cost_tracking.rs
@@ -35,7 +35,7 @@ async fn main() -> Result<()> {
             eprintln!("\nPlease set your OpenAI API key:");
             eprintln!("  export OPENAI_API_KEY='your-api-key-here'\n");
             std::process::exit(1);
-        }
+        },
     };
 
     println!("✓ API key found\n");
@@ -378,6 +378,8 @@ fn format_number(n: usize) -> String {
 #[cfg(not(all(feature = "embeddings", feature = "openai-embeddings")))]
 fn main() {
     eprintln!("This example requires the 'embeddings' and 'openai-embeddings' features.");
-    eprintln!("Run with: cargo run --example openai_cost_tracking --features \"embeddings,openai-embeddings\"");
+    eprintln!(
+        "Run with: cargo run --example openai_cost_tracking --features \"embeddings,openai-embeddings\""
+    );
     std::process::exit(1);
 }
diff --git a/examples/openai_rag.rs b/examples/openai_rag.rs
index 794f8ea..3bceb4d 100644
--- a/examples/openai_rag.rs
+++ b/examples/openai_rag.rs
@@ -38,7 +38,7 @@ async fn main() -> Result<()> {
             eprintln!("\nPlease set your OpenAI API key:");
             eprintln!("  export OPENAI_API_KEY='your-api-key-here'\n");
             std::process::exit(1);
-        }
+        },
     };
 
     println!("✓ API key found\n");
@@ -46,13 +46,34 @@ async fn main() -> Result<()> {
     // 2. Create sample documents to index
     println!("Creating sample documents...");
     let documents = vec![
-        ("rust_intro", "Rust is a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety. It accomplishes these goals without using a garbage collector."),
-        ("rust_ownership", "Rust's ownership system is its most unique feature. The ownership rules ensure memory safety without needing a garbage collector. Each value has a variable that's its owner, and there can only be one owner at a time."),
-        ("rust_cargo", "Cargo is Rust's build system and package manager. It handles building your code, downloading dependencies, and building those dependencies. Most Rustaceans use Cargo to manage their Rust projects."),
-        ("python_intro", "Python is a high-level, interpreted programming language known for its simplicity and readability. It supports multiple programming paradigms and has a comprehensive standard library."),
-        ("python_django", "Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. It follows the model-template-views architectural pattern and includes an ORM."),
-        ("javascript_intro", "JavaScript is a versatile programming language primarily used for web development. It runs in browsers and enables interactive web pages. Node.js allows JavaScript to run on servers too."),
-        ("vecstore_intro", "VecStore is a high-performance vector database written in Rust. It provides efficient similarity search using HNSW indexing, supports multiple embedding backends, and offers both Rust and Python APIs."),
+        (
+            "rust_intro",
+            "Rust is a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety. It accomplishes these goals without using a garbage collector.",
+        ),
+        (
+            "rust_ownership",
+            "Rust's ownership system is its most unique feature. The ownership rules ensure memory safety without needing a garbage collector. Each value has a variable that's its owner, and there can only be one owner at a time.",
+        ),
+        (
+            "rust_cargo",
+            "Cargo is Rust's build system and package manager. It handles building your code, downloading dependencies, and building those dependencies. Most Rustaceans use Cargo to manage their Rust projects.",
+        ),
+        (
+            "python_intro",
+            "Python is a high-level, interpreted programming language known for its simplicity and readability. It supports multiple programming paradigms and has a comprehensive standard library.",
+        ),
+        (
+            "python_django",
+            "Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. It follows the model-template-views architectural pattern and includes an ORM.",
+        ),
+        (
+            "javascript_intro",
+            "JavaScript is a versatile programming language primarily used for web development. It runs in browsers and enables interactive web pages. Node.js allows JavaScript to run on servers too.",
+        ),
+        (
+            "vecstore_intro",
+            "VecStore is a high-performance vector database written in Rust. It provides efficient similarity search using HNSW indexing, supports multiple embedding backends, and offers both Rust and Python APIs.",
+        ),
     ];
 
     println!("✓ Created {} documents", documents.len());
diff --git a/examples/performance_monitoring.rs b/examples/performance_monitoring.rs
index 97143e3..77dea74 100644
--- a/examples/performance_monitoring.rs
+++ b/examples/performance_monitoring.rs
@@ -7,7 +7,7 @@
 //! - Resource utilization
 
 use anyhow::Result;
-use vecstore::{print_health_report, BenchmarkConfig, Benchmarker, HealthChecker, VecStore};
+use vecstore::{BenchmarkConfig, Benchmarker, HealthChecker, VecStore, print_health_report};
 
 fn main() -> Result<()> {
     println!("📊 VecStore Performance Monitoring Example\n");
diff --git a/examples/phrase_matching_demo.rs b/examples/phrase_matching_demo.rs
index 284263d..24f206b 100644
--- a/examples/phrase_matching_demo.rs
+++ b/examples/phrase_matching_demo.rs
@@ -8,7 +8,6 @@
 //!
 //! Run with: cargo run --example phrase_matching_demo
 
-
 // Mock TextIndex for demonstration (in practice, use VecStore's internal TextIndex)
 fn main() {
     println!("=== VecStore Phrase Matching Demo ===\n");
diff --git a/examples/production_ready_system.rs b/examples/production_ready_system.rs
index 1e99208..6d7a2a4 100644
--- a/examples/production_ready_system.rs
+++ b/examples/production_ready_system.rs
@@ -110,13 +110,13 @@ impl VectorSearchService {
                     if let Some(rec) = &alert.recommendation {
                         eprintln!("   → {}", rec);
                     }
-                }
+                },
                 vecstore::AlertSeverity::Warning => {
                     println!("⚠️  WARNING: {}", alert.message);
-                }
+                },
                 vecstore::AlertSeverity::Info => {
                     println!("ℹ️  INFO: {}", alert.message);
-                }
+                },
             }
         }
 
diff --git a/examples/rate_limit_demo.rs b/examples/rate_limit_demo.rs
index c6007ec..0b3eea2 100644
--- a/examples/rate_limit_demo.rs
+++ b/examples/rate_limit_demo.rs
@@ -33,11 +33,7 @@ fn main() -> anyhow::Result<()> {
     println!("\nSending 7 requests:");
     for i in 1..=7 {
         let result = token_limiter.try_acquire_result();
-        let status = if result.allowed {
-            "ALLOWED"
-        } else {
-            "BLOCKED"
-        };
+        let status = if result.allowed { "ALLOWED" } else { "BLOCKED" };
         println!(
             "  Request {}: {} (remaining: {})",
             i, status, result.remaining
@@ -70,11 +66,7 @@ fn main() -> anyhow::Result<()> {
     println!("\nSending 10 requests:");
     for i in 1..=10 {
         let result = burst_limiter.try_acquire_result();
-        let status = if result.allowed {
-            "ALLOWED"
-        } else {
-            "BLOCKED"
-        };
+        let status = if result.allowed { "ALLOWED" } else { "BLOCKED" };
         println!(
             "  Request {}: {} (remaining: {})",
             i, status, result.remaining
@@ -102,11 +94,7 @@ fn main() -> anyhow::Result<()> {
     println!("\nSending 12 requests:");
     for i in 1..=12 {
         let result = sliding_limiter.try_acquire_result();
-        let status = if result.allowed {
-            "ALLOWED"
-        } else {
-            "BLOCKED"
-        };
+        let status = if result.allowed { "ALLOWED" } else { "BLOCKED" };
         println!(
             "  Request {}: {} (remaining: {})",
             i, status, result.remaining
@@ -120,11 +108,7 @@ fn main() -> anyhow::Result<()> {
     println!("\n  After window slides:");
     for i in 13..=15 {
         let result = sliding_limiter.try_acquire_result();
-        let status = if result.allowed {
-            "ALLOWED"
-        } else {
-            "BLOCKED"
-        };
+        let status = if result.allowed { "ALLOWED" } else { "BLOCKED" };
         println!(
             "  Request {}: {} (remaining: {})",
             i, status, result.remaining
@@ -153,11 +137,7 @@ fn main() -> anyhow::Result<()> {
     println!("\nSending 8 requests:");
     for i in 1..=8 {
         let result = leaky_limiter.try_acquire_result();
-        let status = if result.allowed {
-            "ALLOWED"
-        } else {
-            "BLOCKED"
-        };
+        let status = if result.allowed { "ALLOWED" } else { "BLOCKED" };
         println!(
             "  Request {}: {} (remaining: {})",
             i, status, result.remaining
diff --git a/examples/recommender_demo.rs b/examples/recommender_demo.rs
index bf84fe2..916ee37 100644
--- a/examples/recommender_demo.rs
+++ b/examples/recommender_demo.rs
@@ -8,10 +8,10 @@
 
 use anyhow::Result;
 use std::collections::HashMap;
+use vecstore::Metadata;
 use vecstore::recommender::{
     CollaborativeRecommender, ContentBasedRecommender, HybridRecommender, UserPreference,
 };
-use vecstore::Metadata;
 
 fn create_metadata(title: &str, genre: &str, year: i32) -> Metadata {
     let mut fields = HashMap::new();
diff --git a/examples/reranking_demo.rs b/examples/reranking_demo.rs
index eac09e9..fc06a7d 100644
--- a/examples/reranking_demo.rs
+++ b/examples/reranking_demo.rs
@@ -21,8 +21,8 @@
 
 use std::collections::HashMap;
 use vecstore::{
-    reranking::{CrossEncoderFn, IdentityReranker, MMRReranker, Reranker, ScoreReranker},
     Metadata, Query, VecDatabase,
+    reranking::{CrossEncoderFn, IdentityReranker, MMRReranker, Reranker, ScoreReranker},
 };
 
 fn main() -> anyhow::Result<()> {
diff --git a/examples/sparse_vectors_demo.rs b/examples/sparse_vectors_demo.rs
index 37c18df..4562cd3 100644
--- a/examples/sparse_vectors_demo.rs
+++ b/examples/sparse_vectors_demo.rs
@@ -14,8 +14,8 @@
 //! Run with: cargo run --example sparse_vectors_demo
 
 use vecstore::{
-    bm25_score, hybrid_search_score, normalize_scores, BM25Config, BM25Stats, FusionStrategy,
-    HybridQueryV2, HybridSearchConfig, Vector,
+    BM25Config, BM25Stats, FusionStrategy, HybridQueryV2, HybridSearchConfig, Vector, bm25_score,
+    hybrid_search_score, normalize_scores,
 };
 
 fn main() -> anyhow::Result<()> {
diff --git a/examples/streaming_demo.rs b/examples/streaming_demo.rs
index 927522f..0a812ee 100644
--- a/examples/streaming_demo.rs
+++ b/examples/streaming_demo.rs
@@ -5,7 +5,7 @@
 
 use std::collections::HashMap;
 use std::time::Instant;
-use vecstore::{make_record, Metadata, VecStore};
+use vecstore::{Metadata, VecStore, make_record};
 
 fn main() -> anyhow::Result<()> {
     println!("╔═══════════════════════════════════════════════════════════════╗");
diff --git a/examples/text_chunking_demo.rs b/examples/text_chunking_demo.rs
index 04dfcf7..6e8b116 100644
--- a/examples/text_chunking_demo.rs
+++ b/examples/text_chunking_demo.rs
@@ -14,8 +14,8 @@
 
 use std::collections::HashMap;
 use vecstore::{
-    text_splitter::{RecursiveCharacterTextSplitter, TextSplitter, TokenTextSplitter},
     Metadata, Query, VecStore,
+    text_splitter::{RecursiveCharacterTextSplitter, TextSplitter, TokenTextSplitter},
 };
 
 const SAMPLE_DOCUMENT: &str = r#"
diff --git a/examples/validation_demo.rs b/examples/validation_demo.rs
index 056f4d7..6fd2681 100644
--- a/examples/validation_demo.rs
+++ b/examples/validation_demo.rs
@@ -36,13 +36,13 @@ fn main() -> anyhow::Result<()> {
                 for warning in warnings {
                     println!("     {:?}", warning);
                 }
-            }
+            },
             ValidationResult::Invalid(errors) => {
                 println!("❌ INVALID ({} errors)", errors.len());
                 for error in errors {
                     println!("     {:?}", error);
                 }
-            }
+            },
         }
     }
 
@@ -59,10 +59,10 @@ fn main() -> anyhow::Result<()> {
             ValidationResult::Valid => println!("✓ VALID"),
             ValidationResult::Warning(warnings) => {
                 println!("⚠️  {} warnings", warnings.len());
-            }
+            },
             ValidationResult::Invalid(errors) => {
                 println!("❌ {} errors", errors.len());
-            }
+            },
         }
     }
 
@@ -90,7 +90,7 @@ fn main() -> anyhow::Result<()> {
                         "❌ INVALID"
                     }
                 );
-            }
+            },
             Err(e) => println!("  Error:    {}", e),
         }
     }
diff --git a/examples/versioning_demo.rs b/examples/versioning_demo.rs
index 78cad14..1f78c7e 100644
--- a/examples/versioning_demo.rs
+++ b/examples/versioning_demo.rs
@@ -3,8 +3,8 @@
 use anyhow::Result;
 use std::collections::HashMap;
 use tempfile::TempDir;
-use vecstore::versioning::VersionedStore;
 use vecstore::Metadata;
+use vecstore::versioning::VersionedStore;
 
 fn create_metadata(desc: &str) -> Metadata {
     let mut fields = HashMap::new();
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 50b3f5d..f19782d 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,2 +1,2 @@
 [toolchain]
-channel = "1.92"
+channel = "1.92.0"
diff --git a/rustfmt.toml b/rustfmt.toml
index bb4a5ec..61a4558 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -14,34 +14,16 @@ tab_spaces = 4
 # Newline style (native = platform default)
 newline_style = "Auto"
 
-# Import grouping and sorting
-imports_granularity = "Module"
-group_imports = "StdExternalCrate"
+# Import sorting
 reorder_imports = true
 reorder_modules = true
 
-# Format strings
-format_strings = false
-
-# Comments
-wrap_comments = false
-normalize_comments = false
-normalize_doc_attributes = true
-
-# Control flow
-control_brace_style = "AlwaysSameLine"
-
 # Match arms
 match_arm_leading_pipes = "Never"
 match_block_trailing_comma = true
 
 # Function definitions
-fn_args_layout = "Tall"
-fn_single_line = false
-
-# Struct definitions
-struct_lit_single_line = true
-struct_field_align_threshold = 0
+fn_params_layout = "Tall"
 
 # Use field init shorthand
 use_field_init_shorthand = true
@@ -49,12 +31,6 @@ use_field_init_shorthand = true
 # Use try shorthand (?)
 use_try_shorthand = true
 
-# Trailing semicolons
-trailing_semicolon = true
-
-# Where clause layout
-where_single_line = false
-
 # Chain formatting
 chain_width = 60
 
@@ -63,9 +39,3 @@ array_width = 60
 
 # Attribute formatting
 attr_fn_like_width = 70
-
-# Skip certain files/directories (generated code, etc.)
-ignore = [
-    "target/",
-    "proto/",
-]
diff --git a/src/ab_testing.rs b/src/ab_testing.rs
index 03e8926..e27116f 100644
--- a/src/ab_testing.rs
+++ b/src/ab_testing.rs
@@ -2,8 +2,8 @@
 // Compare index types, embedding models, reranking strategies, and more
 
 use std::collections::HashMap;
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::RwLock;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use serde::{Deserialize, Serialize};
@@ -247,8 +247,12 @@ impl ABTestManager {
             variant_data,
         };
 
-        self.experiments.write()?.insert(experiment_id.clone(), state);
-        self.metrics.experiments_created.fetch_add(1, Ordering::Relaxed);
+        self.experiments
+            .write()?
+            .insert(experiment_id.clone(), state);
+        self.metrics
+            .experiments_created
+            .fetch_add(1, Ordering::Relaxed);
 
         Ok(experiment_id)
     }
@@ -256,13 +260,15 @@ impl ABTestManager {
     /// Start an experiment
     pub fn start_experiment(&self, experiment_id: &str) -> Result<()> {
         let mut experiments = self.experiments.write()?;
-        let state = experiments.get_mut(experiment_id)
-            .ok_or_else(|| VecStoreError::NotFound(format!("Experiment {} not found", experiment_id)))?;
+        let state = experiments.get_mut(experiment_id).ok_or_else(|| {
+            VecStoreError::NotFound(format!("Experiment {} not found", experiment_id))
+        })?;
 
         if state.status != ExperimentStatus::Draft && state.status != ExperimentStatus::Paused {
-            return Err(VecStoreError::InvalidInput(
-                format!("Cannot start experiment in status {:?}", state.status)
-            ));
+            return Err(VecStoreError::InvalidInput(format!(
+                "Cannot start experiment in status {:?}",
+                state.status
+            )));
         }
 
         state.status = ExperimentStatus::Running;
@@ -274,11 +280,14 @@ impl ABTestManager {
     /// Pause an experiment
     pub fn pause_experiment(&self, experiment_id: &str) -> Result<()> {
         let mut experiments = self.experiments.write()?;
-        let state = experiments.get_mut(experiment_id)
-            .ok_or_else(|| VecStoreError::NotFound(format!("Experiment {} not found", experiment_id)))?;
+        let state = experiments.get_mut(experiment_id).ok_or_else(|| {
+            VecStoreError::NotFound(format!("Experiment {} not found", experiment_id))
+        })?;
 
         if state.status != ExperimentStatus::Running {
-            return Err(VecStoreError::InvalidInput("Experiment is not running".into()));
+            return Err(VecStoreError::InvalidInput(
+                "Experiment is not running".into(),
+            ));
         }
 
         state.status = ExperimentStatus::Paused;
@@ -288,12 +297,15 @@ impl ABTestManager {
     /// Complete an experiment
     pub fn complete_experiment(&self, experiment_id: &str) -> Result<ExperimentResults> {
         let mut experiments = self.experiments.write()?;
-        let state = experiments.get_mut(experiment_id)
-            .ok_or_else(|| VecStoreError::NotFound(format!("Experiment {} not found", experiment_id)))?;
+        let state = experiments.get_mut(experiment_id).ok_or_else(|| {
+            VecStoreError::NotFound(format!("Experiment {} not found", experiment_id))
+        })?;
 
         state.status = ExperimentStatus::Completed;
         state.ended_at = Some(current_timestamp());
-        self.metrics.experiments_completed.fetch_add(1, Ordering::Relaxed);
+        self.metrics
+            .experiments_completed
+            .fetch_add(1, Ordering::Relaxed);
 
         self.compute_results(state)
     }
@@ -301,13 +313,15 @@ impl ABTestManager {
     /// Get variant assignment for a request
     pub fn get_assignment(&self, experiment_id: &str, identity: &str) -> Result<VariantAssignment> {
         let experiments = self.experiments.read()?;
-        let state = experiments.get(experiment_id)
-            .ok_or_else(|| VecStoreError::NotFound(format!("Experiment {} not found", experiment_id)))?;
+        let state = experiments.get(experiment_id).ok_or_else(|| {
+            VecStoreError::NotFound(format!("Experiment {} not found", experiment_id))
+        })?;
 
         if state.status != ExperimentStatus::Running {
-            return Err(VecStoreError::InvalidInput(
-                format!("Experiment is not running: {:?}", state.status)
-            ));
+            return Err(VecStoreError::InvalidInput(format!(
+                "Experiment is not running: {:?}",
+                state.status
+            )));
         }
 
         // Check for existing assignment (Rust 1.92 if-let chain)
@@ -315,7 +329,10 @@ impl ABTestManager {
         if let Some((exp_id, var_id)) = assignments.get(identity)
             && exp_id == experiment_id
         {
-            let variant = state.config.variants.iter()
+            let variant = state
+                .config
+                .variants
+                .iter()
                 .find(|v| &v.id == var_id)
                 .cloned()
                 .ok_or_else(|| VecStoreError::NotFound("Variant not found".into()))?;
@@ -344,7 +361,9 @@ impl ABTestManager {
         if let Some(vd) = state.variant_data.get(&variant.id) {
             vd.requests.fetch_add(1, Ordering::Relaxed);
         }
-        self.metrics.total_assignments.fetch_add(1, Ordering::Relaxed);
+        self.metrics
+            .total_assignments
+            .fetch_add(1, Ordering::Relaxed);
 
         Ok(VariantAssignment {
             experiment_id: experiment_id.to_string(),
@@ -368,26 +387,28 @@ impl ABTestManager {
                     }
                 }
                 Ok(config.variants[0].clone())
-            }
+            },
             TrafficAllocation::Consistent => {
                 let hash = hash_identity(identity);
                 let idx = (hash as usize) % config.variants.len();
                 Ok(config.variants[idx].clone())
-            }
+            },
             TrafficAllocation::TimeBased { rotation_minutes } => {
                 let now = current_timestamp();
                 let period = (*rotation_minutes as u64) * 60 * 1000;
                 let idx = ((now / period) as usize) % config.variants.len();
                 Ok(config.variants[idx].clone())
-            }
+            },
             TrafficAllocation::Manual => {
                 // Return control by default for manual
-                config.variants.iter()
+                config
+                    .variants
+                    .iter()
                     .find(|v| v.is_control)
                     .or_else(|| config.variants.first())
                     .cloned()
                     .ok_or_else(|| VecStoreError::InvalidInput("No variants defined".into()))
-            }
+            },
         }
     }
 
@@ -399,10 +420,13 @@ impl ABTestManager {
         result: RequestResult,
     ) -> Result<()> {
         let experiments = self.experiments.read()?;
-        let state = experiments.get(experiment_id)
-            .ok_or_else(|| VecStoreError::NotFound(format!("Experiment {} not found", experiment_id)))?;
+        let state = experiments.get(experiment_id).ok_or_else(|| {
+            VecStoreError::NotFound(format!("Experiment {} not found", experiment_id))
+        })?;
 
-        let variant_data = state.variant_data.get(variant_id)
+        let variant_data = state
+            .variant_data
+            .get(variant_id)
             .ok_or_else(|| VecStoreError::NotFound(format!("Variant {} not found", variant_id)))?;
 
         // Update counters
@@ -413,8 +437,13 @@ impl ABTestManager {
         }
 
         // Record latency
-        variant_data.total_latency_us.fetch_add(result.latency_us, Ordering::Relaxed);
-        variant_data.latency_samples.write()?.push(result.latency_us);
+        variant_data
+            .total_latency_us
+            .fetch_add(result.latency_us, Ordering::Relaxed);
+        variant_data
+            .latency_samples
+            .write()?
+            .push(result.latency_us);
 
         // Record metrics
         let mut metrics = variant_data.metric_values.write()?;
@@ -422,7 +451,9 @@ impl ABTestManager {
             metrics.entry(name).or_insert_with(Vec::new).push(value);
         }
 
-        self.metrics.total_results_recorded.fetch_add(1, Ordering::Relaxed);
+        self.metrics
+            .total_results_recorded
+            .fetch_add(1, Ordering::Relaxed);
 
         Ok(())
     }
@@ -430,15 +461,19 @@ impl ABTestManager {
     /// Get current experiment results
     pub fn get_results(&self, experiment_id: &str) -> Result<ExperimentResults> {
         let experiments = self.experiments.read()?;
-        let state = experiments.get(experiment_id)
-            .ok_or_else(|| VecStoreError::NotFound(format!("Experiment {} not found", experiment_id)))?;
+        let state = experiments.get(experiment_id).ok_or_else(|| {
+            VecStoreError::NotFound(format!("Experiment {} not found", experiment_id))
+        })?;
 
         self.compute_results(state)
     }
 
     fn compute_results(&self, state: &ExperimentState) -> Result<ExperimentResults> {
         let mut variant_results = Vec::new();
-        let control_id = state.config.variants.iter()
+        let control_id = state
+            .config
+            .variants
+            .iter()
             .find(|v| v.is_control)
             .map(|v| v.id.clone());
 
@@ -458,18 +493,20 @@ impl ABTestManager {
                 for (name, values) in metrics.iter() {
                     if !values.is_empty() {
                         let mean: f64 = values.iter().sum::<f64>() / values.len() as f64;
-                        let variance: f64 = values.iter()
-                            .map(|v| (v - mean).powi(2))
-                            .sum::<f64>() / values.len() as f64;
+                        let variance: f64 = values.iter().map(|v| (v - mean).powi(2)).sum::<f64>()
+                            / values.len() as f64;
                         let std_dev = variance.sqrt();
 
-                        metric_summaries.insert(name.clone(), MetricSummary {
-                            count: values.len(),
-                            mean,
-                            std_dev,
-                            min: values.iter().cloned().fold(f64::INFINITY, f64::min),
-                            max: values.iter().cloned().fold(f64::NEG_INFINITY, f64::max),
-                        });
+                        metric_summaries.insert(
+                            name.clone(),
+                            MetricSummary {
+                                count: values.len(),
+                                mean,
+                                std_dev,
+                                min: values.iter().cloned().fold(f64::INFINITY, f64::min),
+                                max: values.iter().cloned().fold(f64::NEG_INFINITY, f64::max),
+                            },
+                        );
                     }
                 }
 
@@ -478,9 +515,21 @@ impl ABTestManager {
                     variant_name: variant.name.clone(),
                     is_control: variant.is_control,
                     sample_size: requests,
-                    success_rate: if requests > 0 { successes as f64 / requests as f64 } else { 0.0 },
-                    error_rate: if requests > 0 { errors as f64 / requests as f64 } else { 0.0 },
-                    avg_latency_us: if requests > 0 { total_latency / requests } else { 0 },
+                    success_rate: if requests > 0 {
+                        successes as f64 / requests as f64
+                    } else {
+                        0.0
+                    },
+                    error_rate: if requests > 0 {
+                        errors as f64 / requests as f64
+                    } else {
+                        0.0
+                    },
+                    avg_latency_us: if requests > 0 {
+                        total_latency / requests
+                    } else {
+                        0
+                    },
                     p50_latency_us: p50,
                     p95_latency_us: p95,
                     p99_latency_us: p99,
@@ -490,7 +539,8 @@ impl ABTestManager {
         }
 
         // Compute statistical comparisons
-        let comparisons = self.compute_comparisons(&variant_results, control_id.as_deref(), &state.config);
+        let comparisons =
+            self.compute_comparisons(&variant_results, control_id.as_deref(), &state.config);
 
         // Determine winner
         let winner = self.determine_winner(&variant_results, &comparisons, &state.config);
@@ -543,13 +593,17 @@ impl ABTestManager {
 
                         // Simple t-test approximation
                         let (significant, p) = two_sample_ttest(
-                            c.mean, c.std_dev, c.count,
-                            t.mean, t.std_dev, t.count,
+                            c.mean,
+                            c.std_dev,
+                            c.count,
+                            t.mean,
+                            t.std_dev,
+                            t.count,
                             config.significance_threshold,
                         );
 
                         (change, significant, p)
-                    }
+                    },
                     _ => (0.0, false, 1.0),
                 };
 
@@ -575,9 +629,7 @@ impl ABTestManager {
         config: &ExperimentConfig,
     ) -> Option<String> {
         // Find best performing variant that's statistically significant
-        let significant: Vec<_> = comparisons.iter()
-            .filter(|c| c.is_significant)
-            .collect();
+        let significant: Vec<_> = comparisons.iter().filter(|c| c.is_significant).collect();
 
         if significant.is_empty() {
             return None;
@@ -585,13 +637,13 @@ impl ABTestManager {
 
         // Return the variant with best improvement
         let best = if config.primary_metric.higher_is_better {
-            significant.iter().max_by(|a, b|
-                a.relative_change.total_cmp(&b.relative_change)
-            )
+            significant
+                .iter()
+                .max_by(|a, b| a.relative_change.total_cmp(&b.relative_change))
         } else {
-            significant.iter().min_by(|a, b|
-                a.relative_change.total_cmp(&b.relative_change)
-            )
+            significant
+                .iter()
+                .min_by(|a, b| a.relative_change.total_cmp(&b.relative_change))
         };
 
         best.map(|c| c.variant_id.clone())
@@ -599,16 +651,21 @@ impl ABTestManager {
 
     /// List all experiments
     pub fn list_experiments(&self) -> Result<Vec<ExperimentSummary>> {
-        let experiments = self.experiments.read()
+        let experiments = self
+            .experiments
+            .read()
             .map_err(|_| VecStoreError::LockError("experiments lock poisoned".into()))?;
-        Ok(experiments.iter()
+        Ok(experiments
+            .iter()
             .map(|(id, state)| ExperimentSummary {
                 id: id.clone(),
                 name: state.config.name.clone(),
                 status: state.status.clone(),
                 experiment_type: state.config.experiment_type.clone(),
                 variant_count: state.config.variants.len(),
-                total_requests: state.variant_data.values()
+                total_requests: state
+                    .variant_data
+                    .values()
                     .map(|vd| vd.requests.load(Ordering::Relaxed))
                     .sum(),
                 created_at: state.created_at,
@@ -619,14 +676,19 @@ impl ABTestManager {
 
     /// Get manager stats
     pub fn get_stats(&self) -> Result<ABTestStats> {
-        let experiments = self.experiments.read()
+        let experiments = self
+            .experiments
+            .read()
             .map_err(|_| VecStoreError::LockError("experiments lock poisoned".into()))?;
         Ok(ABTestStats {
             experiments_created: self.metrics.experiments_created.load(Ordering::Relaxed),
             experiments_completed: self.metrics.experiments_completed.load(Ordering::Relaxed),
             total_assignments: self.metrics.total_assignments.load(Ordering::Relaxed),
             total_results_recorded: self.metrics.total_results_recorded.load(Ordering::Relaxed),
-            active_experiments: experiments.values().filter(|s| s.status == ExperimentStatus::Running).count(),
+            active_experiments: experiments
+                .values()
+                .filter(|s| s.status == ExperimentStatus::Running)
+                .count(),
         })
     }
 }
@@ -765,15 +827,28 @@ fn compute_percentiles(samples: &[u64]) -> (u64, u64, u64) {
     let p99_idx = (samples.len() as f64 * 0.99) as usize;
 
     (
-        sorted.get(p50_idx.min(sorted.len() - 1)).copied().unwrap_or(0),
-        sorted.get(p95_idx.min(sorted.len() - 1)).copied().unwrap_or(0),
-        sorted.get(p99_idx.min(sorted.len() - 1)).copied().unwrap_or(0),
+        sorted
+            .get(p50_idx.min(sorted.len() - 1))
+            .copied()
+            .unwrap_or(0),
+        sorted
+            .get(p95_idx.min(sorted.len() - 1))
+            .copied()
+            .unwrap_or(0),
+        sorted
+            .get(p99_idx.min(sorted.len() - 1))
+            .copied()
+            .unwrap_or(0),
     )
 }
 
 fn two_sample_ttest(
-    mean1: f64, std1: f64, n1: usize,
-    mean2: f64, std2: f64, n2: usize,
+    mean1: f64,
+    std1: f64,
+    n1: usize,
+    mean2: f64,
+    std2: f64,
+    n2: usize,
     threshold: f64,
 ) -> (bool, f64) {
     if n1 < 2 || n2 < 2 {
@@ -921,11 +996,17 @@ mod tests {
         let mut metrics = HashMap::new();
         metrics.insert("recall_at_10".to_string(), 0.95);
 
-        manager.record_result(&id, &assignment.variant_id, RequestResult {
-            success: true,
-            latency_us: 5000,
-            metrics,
-        }).unwrap();
+        manager
+            .record_result(
+                &id,
+                &assignment.variant_id,
+                RequestResult {
+                    success: true,
+                    latency_us: 5000,
+                    metrics,
+                },
+            )
+            .unwrap();
 
         let results = manager.get_results(&id).unwrap();
         assert!(!results.variant_results.is_empty());
diff --git a/src/adaptive_cache.rs b/src/adaptive_cache.rs
index e229f0b..1adce9b 100644
--- a/src/adaptive_cache.rs
+++ b/src/adaptive_cache.rs
@@ -30,7 +30,10 @@
 
 use std::collections::{HashMap, VecDeque};
 use std::hash::{Hash, Hasher};
-use std::sync::{RwLock, atomic::{AtomicU64, Ordering}};
+use std::sync::{
+    RwLock,
+    atomic::{AtomicU64, Ordering},
+};
 use std::time::{Duration, Instant};
 
 use serde::{Deserialize, Serialize};
@@ -326,14 +329,16 @@ impl PrefetchPredictor {
     }
 
     fn should_prefetch(&self, query_hash: &str) -> bool {
-        self.patterns.iter()
+        self.patterns
+            .iter()
             .find(|p| p.query_hash == query_hash)
             .map(|p| p.count >= self.min_count)
             .unwrap_or(false)
     }
 
     fn get_frequent_patterns(&self) -> Vec<String> {
-        self.patterns.iter()
+        self.patterns
+            .iter()
             .filter(|p| p.count >= self.min_count)
             .map(|p| p.query_hash.clone())
             .collect()
@@ -390,7 +395,9 @@ impl AdaptiveCache {
 
         // Quick bloom filter check
         if !self.bloom.might_contain(key) {
-            let mut stats = self.l1_stats.write()
+            let mut stats = self
+                .l1_stats
+                .write()
                 .map_err(|_| VecStoreError::LockError("l1_stats lock poisoned".into()))?;
             stats.misses += 1;
             return Ok(None);
@@ -398,12 +405,16 @@ impl AdaptiveCache {
 
         // Check L1 (hot)
         {
-            let mut l1 = self.l1.write()
+            let mut l1 = self
+                .l1
+                .write()
                 .map_err(|_| VecStoreError::LockError("l1 cache lock poisoned".into()))?;
             if let Some(entry) = l1.get_mut(key) {
                 if !entry.is_expired(Duration::from_secs(self.config.l1_ttl_seconds)) {
                     entry.touch();
-                    let mut stats = self.l1_stats.write()
+                    let mut stats = self
+                        .l1_stats
+                        .write()
                         .map_err(|_| VecStoreError::LockError("l1_stats lock poisoned".into()))?;
                     stats.hits += 1;
                     return Ok(Some(entry.value.clone()));
@@ -415,45 +426,61 @@ impl AdaptiveCache {
 
         // Check L2 (warm) and promote to L1
         {
-            let mut l2 = self.l2.write()
+            let mut l2 = self
+                .l2
+                .write()
                 .map_err(|_| VecStoreError::LockError("l2 cache lock poisoned".into()))?;
             if let Some(entry) = l2.remove(key)
-                && !entry.is_expired(Duration::from_secs(self.config.l2_ttl_seconds)) {
-                    let mut stats = self.l2_stats.write()
-                        .map_err(|_| VecStoreError::LockError("l2_stats lock poisoned".into()))?;
-                    stats.hits += 1;
-                    drop(stats);
-                    let value = entry.value.clone();
-                    self.promote_to_l1(key, entry)?;
-                    return Ok(Some(value));
-                }
+                && !entry.is_expired(Duration::from_secs(self.config.l2_ttl_seconds))
+            {
+                let mut stats = self
+                    .l2_stats
+                    .write()
+                    .map_err(|_| VecStoreError::LockError("l2_stats lock poisoned".into()))?;
+                stats.hits += 1;
+                drop(stats);
+                let value = entry.value.clone();
+                self.promote_to_l1(key, entry)?;
+                return Ok(Some(value));
+            }
         }
 
         // Check L3 (disk) and promote to L2
         if self.config.enable_l3 {
-            let mut l3 = self.l3.write()
+            let mut l3 = self
+                .l3
+                .write()
                 .map_err(|_| VecStoreError::LockError("l3 cache lock poisoned".into()))?;
             if let Some(entry) = l3.remove(key)
-                && !entry.is_expired(Duration::from_secs(self.config.l3_ttl_seconds)) {
-                    let mut stats = self.l3_stats.write()
-                        .map_err(|_| VecStoreError::LockError("l3_stats lock poisoned".into()))?;
-                    stats.hits += 1;
-                    drop(stats);
-                    let value = entry.value.clone();
-                    self.promote_to_l2(key, entry)?;
-                    return Ok(Some(value));
-                }
+                && !entry.is_expired(Duration::from_secs(self.config.l3_ttl_seconds))
+            {
+                let mut stats = self
+                    .l3_stats
+                    .write()
+                    .map_err(|_| VecStoreError::LockError("l3_stats lock poisoned".into()))?;
+                stats.hits += 1;
+                drop(stats);
+                let value = entry.value.clone();
+                self.promote_to_l2(key, entry)?;
+                return Ok(Some(value));
+            }
         }
 
         // Miss
-        let mut stats = self.l1_stats.write()
+        let mut stats = self
+            .l1_stats
+            .write()
             .map_err(|_| VecStoreError::LockError("l1_stats lock poisoned".into()))?;
         stats.misses += 1;
         Ok(None)
     }
 
     /// Get with semantic matching
-    pub fn get_semantic(&self, key: &str, query_vector: &[f32]) -> Result<Option<CachedResult>, VecStoreError> {
+    pub fn get_semantic(
+        &self,
+        key: &str,
+        query_vector: &[f32],
+    ) -> Result<Option<CachedResult>, VecStoreError> {
         // Try exact match first
         if let Some(result) = self.get(key)? {
             return Ok(Some(result));
@@ -464,7 +491,9 @@ impl AdaptiveCache {
         }
 
         // Try semantic matching in L1
-        let l1 = self.l1.read()
+        let l1 = self
+            .l1
+            .read()
             .map_err(|_| VecStoreError::LockError("l1 cache lock poisoned".into()))?;
         for (_, entry) in l1.iter() {
             if let Some(ref cached_vector) = entry.query_vector {
@@ -472,7 +501,9 @@ impl AdaptiveCache {
                 if similarity >= self.config.similarity_threshold {
                     let value = entry.value.clone();
                     drop(l1);
-                    let mut stats = self.l1_stats.write()
+                    let mut stats = self
+                        .l1_stats
+                        .write()
                         .map_err(|_| VecStoreError::LockError("l1_stats lock poisoned".into()))?;
                     stats.hits += 1;
                     return Ok(Some(value));
@@ -489,7 +520,12 @@ impl AdaptiveCache {
     }
 
     /// Put with query vector (for semantic matching)
-    pub fn put_with_vector(&self, key: &str, value: CachedResult, query_vector: Option<Vec<f32>>) -> Result<(), VecStoreError> {
+    pub fn put_with_vector(
+        &self,
+        key: &str,
+        value: CachedResult,
+        query_vector: Option<Vec<f32>>,
+    ) -> Result<(), VecStoreError> {
         let size_bytes = estimate_size(&value);
 
         let entry = CacheEntry {
@@ -506,7 +542,9 @@ impl AdaptiveCache {
 
         // Record for prefetching
         if self.config.enable_prefetch {
-            let mut prefetch = self.prefetch.write()
+            let mut prefetch = self
+                .prefetch
+                .write()
                 .map_err(|_| VecStoreError::LockError("prefetch lock poisoned".into()))?;
             prefetch.record(key, query_vector);
         }
@@ -514,11 +552,15 @@ impl AdaptiveCache {
         // Evict if necessary and insert into L1
         self.evict_l1_if_needed()?;
 
-        let mut l1 = self.l1.write()
+        let mut l1 = self
+            .l1
+            .write()
             .map_err(|_| VecStoreError::LockError("l1 cache lock poisoned".into()))?;
         l1.insert(key.to_string(), entry);
 
-        let mut stats = self.l1_stats.write()
+        let mut stats = self
+            .l1_stats
+            .write()
             .map_err(|_| VecStoreError::LockError("l1_stats lock poisoned".into()))?;
         stats.entries = l1.len();
         stats.size_bytes += size_bytes;
@@ -542,7 +584,9 @@ impl AdaptiveCache {
 
         self.bloom.add(key);
 
-        let mut l2 = self.l2.write()
+        let mut l2 = self
+            .l2
+            .write()
             .map_err(|_| VecStoreError::LockError("l2 cache lock poisoned".into()))?;
         l2.insert(key.to_string(), entry);
 
@@ -551,17 +595,23 @@ impl AdaptiveCache {
 
     /// Invalidate cache entry
     pub fn invalidate(&self, key: &str) -> Result<(), VecStoreError> {
-        let mut l1 = self.l1.write()
+        let mut l1 = self
+            .l1
+            .write()
             .map_err(|_| VecStoreError::LockError("l1 cache lock poisoned".into()))?;
         l1.remove(key);
         drop(l1);
 
-        let mut l2 = self.l2.write()
+        let mut l2 = self
+            .l2
+            .write()
             .map_err(|_| VecStoreError::LockError("l2 cache lock poisoned".into()))?;
         l2.remove(key);
         drop(l2);
 
-        let mut l3 = self.l3.write()
+        let mut l3 = self
+            .l3
+            .write()
             .map_err(|_| VecStoreError::LockError("l3 cache lock poisoned".into()))?;
         l3.remove(key);
 
@@ -570,34 +620,46 @@ impl AdaptiveCache {
 
     /// Clear all caches
     pub fn clear(&self) -> Result<(), VecStoreError> {
-        let mut l1 = self.l1.write()
+        let mut l1 = self
+            .l1
+            .write()
             .map_err(|_| VecStoreError::LockError("l1 cache lock poisoned".into()))?;
         l1.clear();
         drop(l1);
 
-        let mut l2 = self.l2.write()
+        let mut l2 = self
+            .l2
+            .write()
             .map_err(|_| VecStoreError::LockError("l2 cache lock poisoned".into()))?;
         l2.clear();
         drop(l2);
 
-        let mut l3 = self.l3.write()
+        let mut l3 = self
+            .l3
+            .write()
             .map_err(|_| VecStoreError::LockError("l3 cache lock poisoned".into()))?;
         l3.clear();
         drop(l3);
 
         self.bloom.clear();
 
-        let mut stats = self.l1_stats.write()
+        let mut stats = self
+            .l1_stats
+            .write()
             .map_err(|_| VecStoreError::LockError("l1_stats lock poisoned".into()))?;
         *stats = TierStats::default();
         drop(stats);
 
-        let mut stats = self.l2_stats.write()
+        let mut stats = self
+            .l2_stats
+            .write()
             .map_err(|_| VecStoreError::LockError("l2_stats lock poisoned".into()))?;
         *stats = TierStats::default();
         drop(stats);
 
-        let mut stats = self.l3_stats.write()
+        let mut stats = self
+            .l3_stats
+            .write()
             .map_err(|_| VecStoreError::LockError("l3_stats lock poisoned".into()))?;
         *stats = TierStats::default();
 
@@ -606,11 +668,17 @@ impl AdaptiveCache {
 
     /// Get cache statistics
     pub fn stats(&self) -> Result<CacheStats, VecStoreError> {
-        let l1_stats = self.l1_stats.read()
+        let l1_stats = self
+            .l1_stats
+            .read()
             .map_err(|_| VecStoreError::LockError("l1_stats lock poisoned".into()))?;
-        let l2_stats = self.l2_stats.read()
+        let l2_stats = self
+            .l2_stats
+            .read()
             .map_err(|_| VecStoreError::LockError("l2_stats lock poisoned".into()))?;
-        let l3_stats = self.l3_stats.read()
+        let l3_stats = self
+            .l3_stats
+            .read()
             .map_err(|_| VecStoreError::LockError("l3_stats lock poisoned".into()))?;
 
         Ok(CacheStats {
@@ -623,38 +691,55 @@ impl AdaptiveCache {
 
     /// Get frequent query patterns for prefetching
     pub fn get_prefetch_candidates(&self) -> Result<Vec<String>, VecStoreError> {
-        let prefetch = self.prefetch.read()
+        let prefetch = self
+            .prefetch
+            .read()
             .map_err(|_| VecStoreError::LockError("prefetch lock poisoned".into()))?;
         Ok(prefetch.get_frequent_patterns())
     }
 
-    fn promote_to_l1(&self, key: &str, mut entry: CacheEntry<CachedResult>) -> Result<(), VecStoreError> {
+    fn promote_to_l1(
+        &self,
+        key: &str,
+        mut entry: CacheEntry<CachedResult>,
+    ) -> Result<(), VecStoreError> {
         entry.touch();
         self.evict_l1_if_needed()?;
 
-        let mut l1 = self.l1.write()
+        let mut l1 = self
+            .l1
+            .write()
             .map_err(|_| VecStoreError::LockError("l1 cache lock poisoned".into()))?;
         l1.insert(key.to_string(), entry);
         Ok(())
     }
 
-    fn promote_to_l2(&self, key: &str, mut entry: CacheEntry<CachedResult>) -> Result<(), VecStoreError> {
+    fn promote_to_l2(
+        &self,
+        key: &str,
+        mut entry: CacheEntry<CachedResult>,
+    ) -> Result<(), VecStoreError> {
         entry.touch();
         self.evict_l2_if_needed()?;
 
-        let mut l2 = self.l2.write()
+        let mut l2 = self
+            .l2
+            .write()
             .map_err(|_| VecStoreError::LockError("l2 cache lock poisoned".into()))?;
         l2.insert(key.to_string(), entry);
         Ok(())
     }
 
     fn evict_l1_if_needed(&self) -> Result<(), VecStoreError> {
-        let mut l1 = self.l1.write()
+        let mut l1 = self
+            .l1
+            .write()
             .map_err(|_| VecStoreError::LockError("l1 cache lock poisoned".into()))?;
 
         while l1.len() >= self.config.l1_size {
             // Find LRU entry
-            let lru_key = l1.iter()
+            let lru_key = l1
+                .iter()
                 .min_by_key(|(_, e)| e.last_access)
                 .map(|(k, _)| k.clone());
 
@@ -663,12 +748,16 @@ impl AdaptiveCache {
                     // Demote to L2 - drop l1 lock first to avoid deadlock
                     drop(l1);
                     self.demote_to_l2(&key, entry)?;
-                    let mut stats = self.l1_stats.write()
+                    let mut stats = self
+                        .l1_stats
+                        .write()
                         .map_err(|_| VecStoreError::LockError("l1_stats lock poisoned".into()))?;
                     stats.evictions += 1;
                     drop(stats);
                     // Re-acquire l1 lock
-                    l1 = self.l1.write()
+                    l1 = self
+                        .l1
+                        .write()
                         .map_err(|_| VecStoreError::LockError("l1 cache lock poisoned".into()))?;
                 }
             } else {
@@ -679,11 +768,14 @@ impl AdaptiveCache {
     }
 
     fn evict_l2_if_needed(&self) -> Result<(), VecStoreError> {
-        let mut l2 = self.l2.write()
+        let mut l2 = self
+            .l2
+            .write()
             .map_err(|_| VecStoreError::LockError("l2 cache lock poisoned".into()))?;
 
         while l2.len() >= self.config.l2_size {
-            let lru_key = l2.iter()
+            let lru_key = l2
+                .iter()
                 .min_by_key(|(_, e)| e.last_access)
                 .map(|(k, _)| k.clone());
 
@@ -694,12 +786,16 @@ impl AdaptiveCache {
                     if self.config.enable_l3 {
                         self.demote_to_l3(&key, entry)?;
                     }
-                    let mut stats = self.l2_stats.write()
+                    let mut stats = self
+                        .l2_stats
+                        .write()
                         .map_err(|_| VecStoreError::LockError("l2_stats lock poisoned".into()))?;
                     stats.evictions += 1;
                     drop(stats);
                     // Re-acquire l2 lock
-                    l2 = self.l2.write()
+                    l2 = self
+                        .l2
+                        .write()
                         .map_err(|_| VecStoreError::LockError("l2 cache lock poisoned".into()))?;
                 }
             } else {
@@ -709,18 +805,30 @@ impl AdaptiveCache {
         Ok(())
     }
 
-    fn demote_to_l2(&self, key: &str, entry: CacheEntry<CachedResult>) -> Result<(), VecStoreError> {
+    fn demote_to_l2(
+        &self,
+        key: &str,
+        entry: CacheEntry<CachedResult>,
+    ) -> Result<(), VecStoreError> {
         self.evict_l2_if_needed()?;
 
-        let mut l2 = self.l2.write()
+        let mut l2 = self
+            .l2
+            .write()
             .map_err(|_| VecStoreError::LockError("l2 cache lock poisoned".into()))?;
         l2.insert(key.to_string(), entry);
         Ok(())
     }
 
-    fn demote_to_l3(&self, key: &str, entry: CacheEntry<CachedResult>) -> Result<(), VecStoreError> {
+    fn demote_to_l3(
+        &self,
+        key: &str,
+        entry: CacheEntry<CachedResult>,
+    ) -> Result<(), VecStoreError> {
         // In production, this would write to disk
-        let mut l3 = self.l3.write()
+        let mut l3 = self
+            .l3
+            .write()
             .map_err(|_| VecStoreError::LockError("l3 cache lock poisoned".into()))?;
         l3.insert(key.to_string(), entry);
         Ok(())
@@ -760,12 +868,7 @@ pub struct CacheKeyGenerator;
 
 impl CacheKeyGenerator {
     /// Generate cache key from query parameters
-    pub fn generate(
-        collection: &str,
-        vector: &[f32],
-        k: usize,
-        filter: Option<&str>,
-    ) -> String {
+    pub fn generate(collection: &str, vector: &[f32], k: usize, filter: Option<&str>) -> String {
         use std::collections::hash_map::DefaultHasher;
 
         let mut hasher = DefaultHasher::new();
@@ -806,9 +909,7 @@ impl CacheKeyGenerator {
 fn estimate_size(result: &CachedResult) -> usize {
     let ids_size: usize = result.ids.iter().map(|s| s.len()).sum();
     let scores_size = result.scores.len() * 4;
-    let meta_size = result.metadata.as_ref()
-        .map(|m| m.len() * 64)
-        .unwrap_or(0);
+    let meta_size = result.metadata.as_ref().map(|m| m.len() * 64).unwrap_or(0);
 
     ids_size + scores_size + meta_size + 64 // overhead
 }
@@ -873,11 +974,16 @@ mod tests {
         let cache = AdaptiveCache::new(config);
 
         for i in 0..5 {
-            cache.put(&format!("key{}", i), CachedResult {
-                ids: vec![],
-                scores: vec![],
-                metadata: None,
-            }).unwrap();
+            cache
+                .put(
+                    &format!("key{}", i),
+                    CachedResult {
+                        ids: vec![],
+                        scores: vec![],
+                        metadata: None,
+                    },
+                )
+                .unwrap();
         }
 
         // L1 should have at most 3 entries
@@ -896,11 +1002,17 @@ mod tests {
         let vector1 = vec![1.0, 0.0, 0.0];
         let vector2 = vec![0.999, 0.001, 0.0]; // Very similar
 
-        cache.put_with_vector("key1", CachedResult {
-            ids: vec!["id1".to_string()],
-            scores: vec![1.0],
-            metadata: None,
-        }, Some(vector1.clone())).unwrap();
+        cache
+            .put_with_vector(
+                "key1",
+                CachedResult {
+                    ids: vec!["id1".to_string()],
+                    scores: vec![1.0],
+                    metadata: None,
+                },
+                Some(vector1.clone()),
+            )
+            .unwrap();
 
         // Should find via semantic matching
         let result = cache.get_semantic("key2", &vector2).unwrap();
@@ -923,11 +1035,16 @@ mod tests {
     fn test_cache_stats() {
         let cache = AdaptiveCache::new(CacheConfig::default());
 
-        cache.put("key1", CachedResult {
-            ids: vec![],
-            scores: vec![],
-            metadata: None,
-        }).unwrap();
+        cache
+            .put(
+                "key1",
+                CachedResult {
+                    ids: vec![],
+                    scores: vec![],
+                    metadata: None,
+                },
+            )
+            .unwrap();
 
         cache.get("key1").unwrap();
         cache.get("nonexistent").unwrap();
diff --git a/src/advanced_filter.rs b/src/advanced_filter.rs
index 03933f8..9717860 100644
--- a/src/advanced_filter.rs
+++ b/src/advanced_filter.rs
@@ -28,7 +28,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use regex::Regex;
 use serde_json::Value;
 
@@ -64,7 +64,7 @@ impl AdvancedFilter {
             AdvancedFilter::JsonPath(path, op, value) => {
                 let extracted = extract_json_path(metadata, path)?;
                 compare_values(&extracted, op, value)
-            }
+            },
             AdvancedFilter::Regex(field, pattern) => {
                 let field_value = extract_field(metadata, field)?;
                 if let Some(s) = field_value.as_str() {
@@ -73,7 +73,7 @@ impl AdvancedFilter {
                 } else {
                     Ok(false)
                 }
-            }
+            },
             AdvancedFilter::ArrayContains(field, value) => {
                 let field_value = extract_field(metadata, field)?;
                 if let Some(arr) = field_value.as_array() {
@@ -81,7 +81,7 @@ impl AdvancedFilter {
                 } else {
                     Ok(false)
                 }
-            }
+            },
             AdvancedFilter::ArrayLength(field, op, length) => {
                 let field_value = extract_field(metadata, field)?;
                 if let Some(arr) = field_value.as_array() {
@@ -90,7 +90,7 @@ impl AdvancedFilter {
                 } else {
                     Ok(false)
                 }
-            }
+            },
             AdvancedFilter::ArrayAll(field, condition) => {
                 let field_value = extract_field(metadata, field)?;
                 if let Some(arr) = field_value.as_array() {
@@ -103,7 +103,7 @@ impl AdvancedFilter {
                 } else {
                     Ok(false)
                 }
-            }
+            },
             AdvancedFilter::ArrayAny(field, condition) => {
                 let field_value = extract_field(metadata, field)?;
                 if let Some(arr) = field_value.as_array() {
@@ -116,7 +116,7 @@ impl AdvancedFilter {
                 } else {
                     Ok(false)
                 }
-            }
+            },
             AdvancedFilter::And(filters) => {
                 for filter in filters {
                     if !filter.matches(metadata)? {
@@ -124,7 +124,7 @@ impl AdvancedFilter {
                     }
                 }
                 Ok(true)
-            }
+            },
             AdvancedFilter::Or(filters) => {
                 for filter in filters {
                     if filter.matches(metadata)? {
@@ -132,12 +132,12 @@ impl AdvancedFilter {
                     }
                 }
                 Ok(false)
-            }
+            },
             AdvancedFilter::Not(filter) => Ok(!filter.matches(metadata)?),
             AdvancedFilter::Basic(field, op, value) => {
                 let field_value = extract_field(metadata, field)?;
                 compare_values(&field_value, op, value)
-            }
+            },
         }
     }
 }
diff --git a/src/advanced_quant.rs b/src/advanced_quant.rs
index 4fa92bf..a95fa94 100644
--- a/src/advanced_quant.rs
+++ b/src/advanced_quant.rs
@@ -312,7 +312,8 @@ impl BinaryQuantizer {
 
     /// Compute Hamming distance (fast binary comparison)
     pub fn hamming_distance(&self, a: &QuantizedVector, b: &QuantizedVector) -> u32 {
-        a.data.iter()
+        a.data
+            .iter()
             .zip(&b.data)
             .map(|(&x, &y)| (x ^ y).count_ones())
             .sum()
@@ -526,7 +527,8 @@ impl FourBitQuantizer {
             }
         }
 
-        self.params.scales = mins.iter()
+        self.params.scales = mins
+            .iter()
             .zip(&maxs)
             .map(|(&min, &max)| (max - min) / 15.0)
             .collect();
@@ -743,13 +745,14 @@ impl AdaptiveQuantizer {
         }
 
         // Allocate bits based on importance
-        let _total_bits = dim * match self.config.stored_bits {
-            BitWidth::Bit1 => 1,
-            BitWidth::Bit1_5 => 2,
-            BitWidth::Bit2 => 2,
-            BitWidth::Bit4 => 4,
-            BitWidth::Bit8 => 8,
-        };
+        let _total_bits = dim
+            * match self.config.stored_bits {
+                BitWidth::Bit1 => 1,
+                BitWidth::Bit1_5 => 2,
+                BitWidth::Bit2 => 2,
+                BitWidth::Bit4 => 4,
+                BitWidth::Bit8 => 8,
+            };
 
         // For now, use uniform allocation (could be optimized)
         self.bit_allocation = vec![self.config.stored_bits; dim];
@@ -812,13 +815,17 @@ impl QuantizedIndex {
             _ => self.four_bit_quantizer.encode(vector),
         };
 
-        let mut vectors = self.vectors.write()
-            .map_err(|_| crate::error::VecStoreError::LockError("Failed to acquire write lock on vectors".into()))?;
+        let mut vectors = self.vectors.write().map_err(|_| {
+            crate::error::VecStoreError::LockError("Failed to acquire write lock on vectors".into())
+        })?;
         vectors.insert(id.to_string(), quantized);
 
         if self.config.rescore {
-            let mut originals = self.original_vectors.write()
-                .map_err(|_| crate::error::VecStoreError::LockError("Failed to acquire write lock on original_vectors".into()))?;
+            let mut originals = self.original_vectors.write().map_err(|_| {
+                crate::error::VecStoreError::LockError(
+                    "Failed to acquire write lock on original_vectors".into(),
+                )
+            })?;
             originals.insert(id.to_string(), vector.to_vec());
         }
 
@@ -827,7 +834,9 @@ impl QuantizedIndex {
 
     /// Search with quantized comparison
     pub fn search(&self, query: &[f32], top_k: usize) -> Vec<(String, f32)> {
-        let Ok(vectors) = self.vectors.read() else { return Vec::new(); };
+        let Ok(vectors) = self.vectors.read() else {
+            return Vec::new();
+        };
 
         // First pass: approximate search with quantized vectors
         let candidates_k = if self.config.rescore {
@@ -843,7 +852,7 @@ impl QuantizedIndex {
                     BitWidth::Bit1 => {
                         let query_q = self.binary_quantizer.encode(query);
                         self.binary_quantizer.binary_similarity(&query_q, qvec)
-                    }
+                    },
                     _ => {
                         let decoded = match qvec.bit_width {
                             BitWidth::Bit2 => self.two_bit_quantizer.decode(qvec),
@@ -851,7 +860,7 @@ impl QuantizedIndex {
                             _ => self.four_bit_quantizer.decode(qvec),
                         };
                         cosine_similarity(&decoded, query)
-                    }
+                    },
                 };
                 (id.clone(), score)
             })
@@ -862,7 +871,9 @@ impl QuantizedIndex {
 
         // Second pass: rescore with original vectors
         if self.config.rescore {
-            let Ok(originals) = self.original_vectors.read() else { return candidates; };
+            let Ok(originals) = self.original_vectors.read() else {
+                return candidates;
+            };
 
             candidates = candidates
                 .into_iter()
@@ -953,7 +964,9 @@ mod tests {
     fn test_binary_quantization() {
         let quantizer = BinaryQuantizer::new(128);
 
-        let vector: Vec<f32> = (0..128).map(|i| if i % 2 == 0 { 0.5 } else { -0.5 }).collect();
+        let vector: Vec<f32> = (0..128)
+            .map(|i| if i % 2 == 0 { 0.5 } else { -0.5 })
+            .collect();
         let encoded = quantizer.encode(&vector);
 
         assert_eq!(encoded.dimension, 128);
@@ -967,13 +980,13 @@ mod tests {
     fn test_ternary_quantization() {
         let quantizer = TernaryQuantizer::new(128, 0.1);
 
-        let vector: Vec<f32> = (0..128).map(|i| {
-            match i % 3 {
+        let vector: Vec<f32> = (0..128)
+            .map(|i| match i % 3 {
                 0 => 0.5,
                 1 => -0.5,
                 _ => 0.0,
-            }
-        }).collect();
+            })
+            .collect();
 
         let encoded = quantizer.encode(&vector);
         let decoded = quantizer.decode(&encoded);
diff --git a/src/agent.rs b/src/agent.rs
index bb3d315..357430c 100644
--- a/src/agent.rs
+++ b/src/agent.rs
@@ -35,7 +35,7 @@
 //! println!("Agent reasoning: {}", result.explanation);
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -168,10 +168,7 @@ pub enum AgentTool {
     },
 
     /// Check privacy constraints
-    PrivacyCheck {
-        operation: String,
-        epsilon: f64,
-    },
+    PrivacyCheck { operation: String, epsilon: f64 },
 
     /// Track lineage
     TrackLineage {
@@ -192,9 +189,15 @@ pub enum FilterExpression {
     /// Less than
     Lt { field: String, value: FilterValue },
     /// In list
-    In { field: String, values: Vec<FilterValue> },
+    In {
+        field: String,
+        values: Vec<FilterValue>,
+    },
     /// Not in list
-    NotIn { field: String, values: Vec<FilterValue> },
+    NotIn {
+        field: String,
+        values: Vec<FilterValue>,
+    },
     /// Contains (for text/arrays)
     Contains { field: String, value: String },
     /// And combination
@@ -413,11 +416,17 @@ pub struct IntentConstraint {
 /// Intent modifiers
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum IntentModifier {
-    TimeRange { start: Option<String>, end: Option<String> },
+    TimeRange {
+        start: Option<String>,
+        end: Option<String>,
+    },
     Limit(usize),
     Exclude(Vec<String>),
     Include(Vec<String>),
-    SortBy { field: String, ascending: bool },
+    SortBy {
+        field: String,
+        ascending: bool,
+    },
 }
 
 // ============================================================================
@@ -597,9 +606,10 @@ impl QueryAgent {
         // Parse limits
         if let Some(pos) = query_lower.find("top ")
             && let Some(num_str) = query_lower[pos + 4..].split_whitespace().next()
-                && let Ok(n) = num_str.parse::<usize>() {
-                    modifiers.push(IntentModifier::Limit(n));
-                }
+            && let Ok(n) = num_str.parse::<usize>()
+        {
+            modifiers.push(IntentModifier::Limit(n));
+        }
 
         Ok(QueryIntent {
             action,
@@ -701,7 +711,7 @@ impl QueryAgent {
                     confidence: 0.85,
                     fallback: None,
                 });
-            }
+            },
 
             IntentAction::Explain => {
                 steps.push(PlanStep {
@@ -716,7 +726,7 @@ impl QueryAgent {
                     confidence: 0.9,
                     fallback: None,
                 });
-            }
+            },
 
             IntentAction::Aggregate => {
                 steps.push(PlanStep {
@@ -732,7 +742,7 @@ impl QueryAgent {
                     confidence: 0.95,
                     fallback: None,
                 });
-            }
+            },
 
             _ => {
                 // Default to search
@@ -750,7 +760,7 @@ impl QueryAgent {
                     confidence: 0.8,
                     fallback: None,
                 });
-            }
+            },
         }
 
         let overall_confidence = steps.iter().map(|s| s.confidence).product::<f32>();
@@ -798,7 +808,11 @@ impl QueryAgent {
 
             trace.push(ExecutionStep {
                 step: step.step,
-                tool: format!("{:?}", step.tool).split('{').next().unwrap().to_string(),
+                tool: format!("{:?}", step.tool)
+                    .split('{')
+                    .next()
+                    .unwrap()
+                    .to_string(),
                 input_summary: format!("{} input items", current_ids.len()),
                 output_summary: format!("{} output items", result.result_ids.len()),
                 success: result.success,
@@ -856,36 +870,46 @@ impl QueryAgent {
                 let scores: Vec<f32> = (0..*k).map(|i| 1.0 - (i as f32 * 0.05)).collect();
                 let _ = (query, filters); // Mark as used
                 (ids, scores, None)
-            }
+            },
             AgentTool::KeywordSearch { query, k, filters } => {
                 // Keyword search using BM25-style scoring
                 let ids: Vec<String> = (0..*k).map(|i| format!("kw_result_{}", i)).collect();
                 let scores: Vec<f32> = (0..*k).map(|i| 0.9 - (i as f32 * 0.08)).collect();
                 let _ = (query, filters); // Mark as used
                 (ids, scores, None)
-            }
+            },
             AgentTool::HybridSearch { k, alpha, .. } => {
                 // Hybrid search combining vector and keyword
                 let ids: Vec<String> = (0..*k).map(|i| format!("hybrid_result_{}", i)).collect();
-                let scores: Vec<f32> = (0..*k).map(|i| {
-                    // Blend scores based on alpha
-                    let vec_score = 1.0 - (i as f32 * 0.05);
-                    let kw_score = 0.9 - (i as f32 * 0.08);
-                    alpha * vec_score + (1.0 - alpha) * kw_score
-                }).collect();
+                let scores: Vec<f32> = (0..*k)
+                    .map(|i| {
+                        // Blend scores based on alpha
+                        let vec_score = 1.0 - (i as f32 * 0.05);
+                        let kw_score = 0.9 - (i as f32 * 0.08);
+                        alpha * vec_score + (1.0 - alpha) * kw_score
+                    })
+                    .collect();
                 (ids, scores, None)
-            }
-            AgentTool::Filter { expression, input_ids: filter_input } => {
+            },
+            AgentTool::Filter {
+                expression,
+                input_ids: filter_input,
+            } => {
                 // Filter operation - returns subset of input IDs matching expression
-                let ids: Vec<String> = filter_input.iter()
+                let ids: Vec<String> = filter_input
+                    .iter()
                     .take(filter_input.len() / 2 + 1)
                     .cloned()
                     .collect();
                 let scores: Vec<f32> = vec![1.0; ids.len()];
                 let _ = expression; // Mark as used
                 (ids, scores, None)
-            }
-            AgentTool::Aggregate { operation, input_ids: agg_input, .. } => {
+            },
+            AgentTool::Aggregate {
+                operation,
+                input_ids: agg_input,
+                ..
+            } => {
                 // Aggregate operation
                 let agg_result = match operation {
                     AggregateOp::Count => Some(AggregationResult {
@@ -927,11 +951,14 @@ impl QueryAgent {
                             count: agg_input.len(),
                             groups: Some(groups),
                         })
-                    }
+                    },
                 };
                 (agg_input.clone(), vec![1.0; agg_input.len()], agg_result)
-            }
-            AgentTool::Transform { operation, input_ids: transform_input } => {
+            },
+            AgentTool::Transform {
+                operation,
+                input_ids: transform_input,
+            } => {
                 // Transform operation
                 let ids = match operation {
                     TransformOp::Normalize => transform_input.clone(),
@@ -939,50 +966,53 @@ impl QueryAgent {
                     TransformOp::Cluster { k } => {
                         // Return k cluster representatives
                         transform_input.iter().take(*k).cloned().collect()
-                    }
+                    },
                     TransformOp::Deduplicate { .. } => {
                         // Remove duplicates by taking first half as "unique"
                         let unique_count = (transform_input.len() / 2).max(1);
                         transform_input.iter().take(unique_count).cloned().collect()
-                    }
+                    },
                     TransformOp::Enrich { .. } => transform_input.clone(),
                 };
                 let scores = vec![1.0; ids.len()];
                 (ids, scores, None)
-            }
+            },
             AgentTool::Fetch { ids } => {
                 // Fetch by IDs - return the requested IDs
                 let scores = vec![1.0; ids.len()];
                 (ids.clone(), scores, None)
-            }
-            AgentTool::Rerank { k, input_ids: rerank_input, .. } => {
+            },
+            AgentTool::Rerank {
+                k,
+                input_ids: rerank_input,
+                ..
+            } => {
                 // Rerank - reorder based on relevance
-                let mut reranked: Vec<(usize, f32)> = rerank_input.iter()
+                let mut reranked: Vec<(usize, f32)> = rerank_input
+                    .iter()
                     .enumerate()
                     .map(|(i, _)| (i, 1.0 / (1.0 + i as f32)))
                     .collect();
                 reranked.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
 
-                let ids: Vec<String> = reranked.iter()
+                let ids: Vec<String> = reranked
+                    .iter()
                     .take(*k)
                     .map(|(i, _)| rerank_input[*i].clone())
                     .collect();
-                let scores: Vec<f32> = reranked.iter()
-                    .take(*k)
-                    .map(|(_, s)| *s)
-                    .collect();
+                let scores: Vec<f32> = reranked.iter().take(*k).map(|(_, s)| *s).collect();
                 (ids, scores, None)
-            }
+            },
             AgentTool::Explain { result_id, .. } => {
                 // Explain - return explanation for a result
                 (vec![result_id.clone()], vec![1.0], None)
-            }
+            },
             AgentTool::TemporalSearch { k, .. } => {
                 // Temporal search - filter by time range
                 let ids: Vec<String> = (0..*k).map(|i| format!("temporal_result_{}", i)).collect();
                 let scores: Vec<f32> = (0..*k).map(|i| 1.0 - (i as f32 * 0.05)).collect();
                 (ids, scores, None)
-            }
+            },
             AgentTool::PrivacyCheck { epsilon, .. } => {
                 // Privacy check - verify privacy constraints
                 // Return whether the privacy budget allows the operation
@@ -993,11 +1023,11 @@ impl QueryAgent {
                     vec!["privacy_denied".to_string()]
                 };
                 (ids, vec![if approved { 1.0 } else { 0.0 }], None)
-            }
+            },
             AgentTool::TrackLineage { vector_id, .. } => {
                 // Track lineage - return the vector ID with lineage info
                 (vec![vector_id.clone()], vec![1.0], None)
-            }
+            },
         };
 
         // Use input_ids if provided and result is empty
@@ -1026,7 +1056,11 @@ impl QueryAgent {
     }
 
     /// Generate explanation
-    fn generate_explanation(&self, plan: &ExecutionPlan, trace: &[ExecutionStep]) -> Result<String> {
+    fn generate_explanation(
+        &self,
+        plan: &ExecutionPlan,
+        trace: &[ExecutionStep],
+    ) -> Result<String> {
         let mut explanation = String::new();
 
         explanation.push_str(&format!("Query: \"{}\"\n\n", plan.query));
@@ -1052,7 +1086,11 @@ impl QueryAgent {
     }
 
     /// Generate suggestions for query refinement
-    fn generate_suggestions(&self, intent: &QueryIntent, results: &[String]) -> Result<Vec<String>> {
+    fn generate_suggestions(
+        &self,
+        intent: &QueryIntent,
+        results: &[String],
+    ) -> Result<Vec<String>> {
         let mut suggestions = Vec::new();
 
         if results.is_empty() {
@@ -1063,7 +1101,10 @@ impl QueryAgent {
         }
 
         // Check for time-related suggestions
-        let has_time_modifier = intent.modifiers.iter().any(|m| matches!(m, IntentModifier::TimeRange { .. }));
+        let has_time_modifier = intent
+            .modifiers
+            .iter()
+            .any(|m| matches!(m, IntentModifier::TimeRange { .. }));
         if !has_time_modifier {
             suggestions.push("Add time range to focus on recent items".to_string());
         }
@@ -1163,7 +1204,11 @@ impl TransformAgent {
     }
 
     /// Transform vectors based on instruction
-    pub async fn transform(&self, instruction: &str, vectors: &[Vec<f32>]) -> Result<TransformResult> {
+    pub async fn transform(
+        &self,
+        instruction: &str,
+        vectors: &[Vec<f32>],
+    ) -> Result<TransformResult> {
         let start_time = std::time::Instant::now();
 
         // Parse transformation instruction
@@ -1200,21 +1245,23 @@ impl TransformAgent {
         }
     }
 
-    fn apply_transform(&self, operation: &TransformOp, vectors: &[Vec<f32>]) -> Result<Vec<Vec<f32>>> {
+    fn apply_transform(
+        &self,
+        operation: &TransformOp,
+        vectors: &[Vec<f32>],
+    ) -> Result<Vec<Vec<f32>>> {
         match operation {
-            TransformOp::Normalize => {
-                Ok(vectors
-                    .iter()
-                    .map(|v| {
-                        let norm: f32 = v.iter().map(|x| x * x).sum::<f32>().sqrt();
-                        if norm > 0.0 {
-                            v.iter().map(|x| x / norm).collect()
-                        } else {
-                            v.clone()
-                        }
-                    })
-                    .collect())
-            }
+            TransformOp::Normalize => Ok(vectors
+                .iter()
+                .map(|v| {
+                    let norm: f32 = v.iter().map(|x| x * x).sum::<f32>().sqrt();
+                    if norm > 0.0 {
+                        v.iter().map(|x| x / norm).collect()
+                    } else {
+                        v.clone()
+                    }
+                })
+                .collect()),
 
             TransformOp::ReduceDimensions { target_dim } => {
                 // Simplified: just truncate (would use PCA in production)
@@ -1222,7 +1269,7 @@ impl TransformAgent {
                     .iter()
                     .map(|v| v.iter().take(*target_dim).cloned().collect())
                     .collect())
-            }
+            },
 
             TransformOp::Deduplicate { threshold } => {
                 // Simple deduplication based on cosine similarity
@@ -1242,7 +1289,7 @@ impl TransformAgent {
                 }
 
                 Ok(unique)
-            }
+            },
 
             _ => Ok(vectors.to_vec()),
         }
@@ -1449,9 +1496,10 @@ impl ComplianceAgent {
 
         // Check data retention
         if let Some(ref policy) = operation.retention_policy
-            && policy.max_retention_days < 30 {
-                warnings.push("Short retention policy may affect analytics".to_string());
-            }
+            && policy.max_retention_days < 30
+        {
+            warnings.push("Short retention policy may affect analytics".to_string());
+        }
 
         // Check access permissions
         if operation.requires_pii && !operation.has_pii_access {
@@ -1481,7 +1529,12 @@ impl ComplianceAgent {
     }
 
     /// Track lineage for an operation
-    pub fn track_lineage(&self, operation: &str, inputs: &[String], outputs: &[String]) -> LineageRecord {
+    pub fn track_lineage(
+        &self,
+        operation: &str,
+        inputs: &[String],
+        outputs: &[String],
+    ) -> LineageRecord {
         LineageRecord {
             operation: operation.to_string(),
             timestamp: chrono::Utc::now().timestamp(),
@@ -1587,10 +1640,7 @@ mod tests {
     async fn test_transform_agent() {
         let agent = TransformAgent::new(AgentConfig::default());
 
-        let vectors = vec![
-            vec![1.0, 2.0, 3.0],
-            vec![4.0, 5.0, 6.0],
-        ];
+        let vectors = vec![vec![1.0, 2.0, 3.0], vec![4.0, 5.0, 6.0]];
 
         let result = agent.transform("normalize", &vectors).await.unwrap();
 
@@ -1624,10 +1674,7 @@ mod tests {
             },
         );
 
-        let results = vec![
-            ("item1".to_string(), 0.8),
-            ("item2".to_string(), 0.9),
-        ];
+        let results = vec![("item1".to_string(), 0.8), ("item2".to_string(), 0.9)];
 
         let personalized = agent.personalize("user1", &results).await.unwrap();
 
diff --git a/src/agentic.rs b/src/agentic.rs
index acdcf7f..9c76cd9 100644
--- a/src/agentic.rs
+++ b/src/agentic.rs
@@ -525,10 +525,12 @@ impl QueryDecomposer {
 
         // Look for capitalized words as potential entities
         for word in query.split_whitespace() {
-            if word.len() > 1 && word.chars().next().unwrap().is_uppercase()
-                && !STOP_WORDS.contains(&word.to_lowercase().as_str()) {
-                    entities.push(word.to_string());
-                }
+            if word.len() > 1
+                && word.chars().next().unwrap().is_uppercase()
+                && !STOP_WORDS.contains(&word.to_lowercase().as_str())
+            {
+                entities.push(word.to_string());
+            }
         }
 
         for (i, entity) in entities.iter().take(self.max_sub_queries).enumerate() {
@@ -563,9 +565,15 @@ impl QueryDecomposer {
         let query_lower = query.to_lowercase();
 
         // Check for temporal indicators
-        let has_recent = query_lower.contains("recent") || query_lower.contains("latest") || query_lower.contains("new");
-        let has_past = query_lower.contains("previous") || query_lower.contains("old") || query_lower.contains("historical");
-        let has_future = query_lower.contains("upcoming") || query_lower.contains("future") || query_lower.contains("next");
+        let has_recent = query_lower.contains("recent")
+            || query_lower.contains("latest")
+            || query_lower.contains("new");
+        let has_past = query_lower.contains("previous")
+            || query_lower.contains("old")
+            || query_lower.contains("historical");
+        let has_future = query_lower.contains("upcoming")
+            || query_lower.contains("future")
+            || query_lower.contains("next");
 
         if has_recent {
             sub_queries.push(SubQuery {
@@ -624,11 +632,17 @@ impl QueryDecomposer {
 
         // Common aspects to search for
         let aspects = [
-            ("price", vec!["price", "cost", "cheap", "expensive", "affordable"]),
+            (
+                "price",
+                vec!["price", "cost", "cheap", "expensive", "affordable"],
+            ),
             ("quality", vec!["quality", "best", "top", "premium", "good"]),
             ("reviews", vec!["review", "rating", "feedback", "opinion"]),
             ("features", vec!["feature", "specification", "capability"]),
-            ("comparison", vec!["compare", "vs", "versus", "better", "difference"]),
+            (
+                "comparison",
+                vec!["compare", "vs", "versus", "better", "difference"],
+            ),
         ];
 
         let query_lower = query.to_lowercase();
@@ -685,14 +699,23 @@ impl ResultFuser {
             FusionStrategy::RRF { k } => self.fuse_rrf(branch_results, *k, top_k),
             FusionStrategy::WeightedSum => self.fuse_weighted(branch_results, top_k),
             FusionStrategy::MaxScore => self.fuse_max(branch_results, top_k),
-            FusionStrategy::Voting { min_votes } => self.fuse_voting(branch_results, *min_votes, top_k),
+            FusionStrategy::Voting { min_votes } => {
+                self.fuse_voting(branch_results, *min_votes, top_k)
+            },
             FusionStrategy::LLMRerank => self.fuse_weighted(branch_results, top_k), // Fallback
             FusionStrategy::CrossEncoder => self.fuse_weighted(branch_results, top_k), // Fallback
         }
     }
 
     fn fuse_rrf(&self, branch_results: &[BranchResult], k: f32, top_k: usize) -> Vec<FusedResult> {
-        let mut doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, serde_json::Value>)> = HashMap::new();
+        let mut doc_scores: HashMap<
+            String,
+            (
+                f32,
+                HashMap<String, f32>,
+                HashMap<String, serde_json::Value>,
+            ),
+        > = HashMap::new();
 
         for branch in branch_results {
             if !branch.success {
@@ -702,9 +725,9 @@ impl ResultFuser {
             for (rank, result) in branch.results.iter().enumerate() {
                 let rrf_score = 1.0 / (k + rank as f32 + 1.0);
 
-                let entry = doc_scores.entry(result.id.clone()).or_insert_with(|| {
-                    (0.0, HashMap::new(), result.metadata.clone())
-                });
+                let entry = doc_scores
+                    .entry(result.id.clone())
+                    .or_insert_with(|| (0.0, HashMap::new(), result.metadata.clone()));
 
                 entry.0 += rrf_score;
                 entry.1.insert(branch.sub_query_id.clone(), result.score);
@@ -729,7 +752,14 @@ impl ResultFuser {
     }
 
     fn fuse_weighted(&self, branch_results: &[BranchResult], top_k: usize) -> Vec<FusedResult> {
-        let mut doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, serde_json::Value>)> = HashMap::new();
+        let mut doc_scores: HashMap<
+            String,
+            (
+                f32,
+                HashMap<String, f32>,
+                HashMap<String, serde_json::Value>,
+            ),
+        > = HashMap::new();
 
         for branch in branch_results {
             if !branch.success {
@@ -737,9 +767,9 @@ impl ResultFuser {
             }
 
             for result in &branch.results {
-                let entry = doc_scores.entry(result.id.clone()).or_insert_with(|| {
-                    (0.0, HashMap::new(), result.metadata.clone())
-                });
+                let entry = doc_scores
+                    .entry(result.id.clone())
+                    .or_insert_with(|| (0.0, HashMap::new(), result.metadata.clone()));
 
                 entry.0 += result.score;
                 entry.1.insert(branch.sub_query_id.clone(), result.score);
@@ -764,7 +794,14 @@ impl ResultFuser {
     }
 
     fn fuse_max(&self, branch_results: &[BranchResult], top_k: usize) -> Vec<FusedResult> {
-        let mut doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, serde_json::Value>)> = HashMap::new();
+        let mut doc_scores: HashMap<
+            String,
+            (
+                f32,
+                HashMap<String, f32>,
+                HashMap<String, serde_json::Value>,
+            ),
+        > = HashMap::new();
 
         for branch in branch_results {
             if !branch.success {
@@ -772,9 +809,9 @@ impl ResultFuser {
             }
 
             for result in &branch.results {
-                let entry = doc_scores.entry(result.id.clone()).or_insert_with(|| {
-                    (0.0, HashMap::new(), result.metadata.clone())
-                });
+                let entry = doc_scores
+                    .entry(result.id.clone())
+                    .or_insert_with(|| (0.0, HashMap::new(), result.metadata.clone()));
 
                 if result.score > entry.0 {
                     entry.0 = result.score;
@@ -800,8 +837,20 @@ impl ResultFuser {
         fused
     }
 
-    fn fuse_voting(&self, branch_results: &[BranchResult], min_votes: usize, top_k: usize) -> Vec<FusedResult> {
-        let mut doc_votes: HashMap<String, (usize, HashMap<String, f32>, HashMap<String, serde_json::Value>)> = HashMap::new();
+    fn fuse_voting(
+        &self,
+        branch_results: &[BranchResult],
+        min_votes: usize,
+        top_k: usize,
+    ) -> Vec<FusedResult> {
+        let mut doc_votes: HashMap<
+            String,
+            (
+                usize,
+                HashMap<String, f32>,
+                HashMap<String, serde_json::Value>,
+            ),
+        > = HashMap::new();
 
         for branch in branch_results {
             if !branch.success {
@@ -809,9 +858,9 @@ impl ResultFuser {
             }
 
             for result in &branch.results {
-                let entry = doc_votes.entry(result.id.clone()).or_insert_with(|| {
-                    (0, HashMap::new(), result.metadata.clone())
-                });
+                let entry = doc_votes
+                    .entry(result.id.clone())
+                    .or_insert_with(|| (0, HashMap::new(), result.metadata.clone()));
 
                 entry.0 += 1;
                 entry.1.insert(branch.sub_query_id.clone(), result.score);
@@ -952,7 +1001,9 @@ impl AgentExecutor {
     /// Save agent state
     pub fn save_state(&self, state: &AgentState) {
         let key = format!("{}:{}", state.agent_id, state.session_id);
-        let Ok(mut states) = self.states.write() else { return; };
+        let Ok(mut states) = self.states.write() else {
+            return;
+        };
         states.insert(key, state.clone());
     }
 
@@ -1006,7 +1057,9 @@ impl AgentExecutor {
     /// Register a tool
     pub fn register_tool(&self, agent_id: &str, session_id: &str, tool: ToolDefinition) {
         let key = format!("{}:{}", agent_id, session_id);
-        let Ok(mut states) = self.states.write() else { return; };
+        let Ok(mut states) = self.states.write() else {
+            return;
+        };
 
         if let Some(state) = states.get_mut(&key) {
             state.register_tool(tool);
@@ -1068,13 +1121,12 @@ pub struct AgentStats {
 
 // Stop words for filtering
 const STOP_WORDS: &[&str] = &[
-    "a", "an", "the", "and", "or", "but", "in", "on", "at", "to", "for",
-    "of", "with", "by", "from", "as", "is", "was", "are", "were", "been",
-    "be", "have", "has", "had", "do", "does", "did", "will", "would", "could",
-    "should", "may", "might", "must", "shall", "can", "need", "dare", "ought",
-    "used", "that", "which", "who", "whom", "this", "these", "those", "what",
-    "i", "me", "my", "we", "our", "you", "your", "he", "him", "his", "she",
-    "her", "it", "its", "they", "them", "their",
+    "a", "an", "the", "and", "or", "but", "in", "on", "at", "to", "for", "of", "with", "by",
+    "from", "as", "is", "was", "are", "were", "been", "be", "have", "has", "had", "do", "does",
+    "did", "will", "would", "could", "should", "may", "might", "must", "shall", "can", "need",
+    "dare", "ought", "used", "that", "which", "who", "whom", "this", "these", "those", "what", "i",
+    "me", "my", "we", "our", "you", "your", "he", "him", "his", "she", "her", "it", "its", "they",
+    "them", "their",
 ];
 
 #[cfg(test)]
@@ -1084,7 +1136,9 @@ mod tests {
     #[test]
     fn test_query_decomposition() {
         let decomposer = QueryDecomposer::new(DecompositionStrategy::Semantic, 5);
-        let sub_queries = decomposer.decompose("Find products similar to iPhone and cheaper than $500").unwrap();
+        let sub_queries = decomposer
+            .decompose("Find products similar to iPhone and cheaper than $500")
+            .unwrap();
 
         assert!(!sub_queries.is_empty());
     }
@@ -1174,7 +1228,9 @@ mod tests {
     #[test]
     fn test_query_planner() {
         let planner = QueryPlanner::new(DecompositionStrategy::Semantic, 5);
-        let plan = planner.plan("Find red cars with good fuel efficiency").unwrap();
+        let plan = planner
+            .plan("Find red cars with good fuel efficiency")
+            .unwrap();
 
         assert!(!plan.sub_queries.is_empty());
         assert!(!plan.execution_order.is_empty());
diff --git a/src/analytics.rs b/src/analytics.rs
index 2fb5239..4110462 100644
--- a/src/analytics.rs
+++ b/src/analytics.rs
@@ -584,7 +584,8 @@ impl VectorAnalytics {
             let mut min_dist = f32::MAX;
             for (j, v) in vectors.iter().enumerate() {
                 if j != idx {
-                    let dist: f32 = point.iter()
+                    let dist: f32 = point
+                        .iter()
                         .zip(v.iter())
                         .map(|(a, b)| (a - b).powi(2))
                         .sum::<f32>()
@@ -606,7 +607,8 @@ impl VectorAnalytics {
             // Find nearest neighbor distance to data
             let mut min_dist = f32::MAX;
             for v in vectors {
-                let dist: f32 = random_point.iter()
+                let dist: f32 = random_point
+                    .iter()
                     .zip(v.iter())
                     .map(|(a, b)| (a - b).powi(2))
                     .sum::<f32>()
diff --git a/src/anomaly.rs b/src/anomaly.rs
index 0ee8416..f3dff8f 100644
--- a/src/anomaly.rs
+++ b/src/anomaly.rs
@@ -165,7 +165,7 @@ impl IsolationForest {
             IsolationTree::Leaf { size } => {
                 // Adjust for unsuccessful search
                 height as f32 + Self::average_path_length(*size)
-            }
+            },
             IsolationTree::Node {
                 feature,
                 split_value,
@@ -177,7 +177,7 @@ impl IsolationForest {
                 } else {
                     self.path_length(vector, right, height + 1)
                 }
-            }
+            },
         }
     }
 
@@ -278,11 +278,7 @@ impl LocalOutlierFactor {
             .enumerate()
             .filter_map(|(i, v)| {
                 let dist = euclidean_distance_simd(vector, v);
-                if dist > 0.0 {
-                    Some((i, dist))
-                } else {
-                    None
-                }
+                if dist > 0.0 { Some((i, dist)) } else { None }
             })
             .collect();
 
diff --git a/src/anomaly_detection.rs b/src/anomaly_detection.rs
index 1418765..3b5e38e 100644
--- a/src/anomaly_detection.rs
+++ b/src/anomaly_detection.rs
@@ -2,8 +2,8 @@
 // Outlier detection, drift monitoring, and data quality analysis
 
 use std::collections::{HashMap, VecDeque};
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::RwLock;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, Instant};
 
 use serde::{Deserialize, Serialize};
@@ -240,27 +240,29 @@ impl AnomalyDetector {
         let model = match self.config.method {
             DetectionMethod::IsolationForest => {
                 DetectorModel::IsolationForest(self.build_isolation_forest(vectors)?)
-            }
-            DetectionMethod::LOF => {
-                DetectorModel::LOF(self.build_lof(vectors)?)
-            }
+            },
+            DetectionMethod::LOF => DetectorModel::LOF(self.build_lof(vectors)?),
             DetectionMethod::Statistical => {
                 DetectorModel::Statistical(self.build_statistical(vectors)?)
-            }
+            },
             DetectionMethod::Ensemble => {
                 let detectors: Vec<Box<dyn Detector + Send + Sync>> = Vec::new();
                 // Would add multiple detectors here
                 DetectorModel::Ensemble(detectors)
-            }
-            _ => {
-                DetectorModel::Statistical(self.build_statistical(vectors)?)
-            }
+            },
+            _ => DetectorModel::Statistical(self.build_statistical(vectors)?),
         };
 
-        *self.model.write()
+        *self
+            .model
+            .write()
             .map_err(|_| VecStoreError::LockError("model lock poisoned".into()))? = Some(model);
-        *self.stats.last_training.write()
-            .map_err(|_| VecStoreError::LockError("last_training lock poisoned".into()))? = Some(Instant::now());
+        *self
+            .stats
+            .last_training
+            .write()
+            .map_err(|_| VecStoreError::LockError("last_training lock poisoned".into()))? =
+            Some(Instant::now());
 
         Ok(())
     }
@@ -279,16 +281,15 @@ impl AnomalyDetector {
                 .map(|_| random_usize(0, vectors.len()))
                 .collect();
 
-            let samples: Vec<&Vec<f32>> = sample_indices.iter()
-                .map(|&i| &vectors[i])
-                .collect();
+            let samples: Vec<&Vec<f32>> = sample_indices.iter().map(|&i| &vectors[i]).collect();
 
             let tree = self.build_tree(&samples, 0, max_depth);
             trees.push(tree);
         }
 
         // Compute threshold based on contamination
-        let scores: Vec<f64> = vectors.iter()
+        let scores: Vec<f64> = vectors
+            .iter()
             .map(|v| self.compute_path_length(&trees, v))
             .collect();
 
@@ -303,7 +304,9 @@ impl AnomalyDetector {
 
     fn build_tree(&self, samples: &[&Vec<f32>], depth: usize, max_depth: usize) -> IsolationTree {
         if samples.len() <= 1 || depth >= max_depth {
-            return IsolationTree::Leaf { size: samples.len() };
+            return IsolationTree::Leaf {
+                size: samples.len(),
+            };
         }
 
         let dim = samples[0].len();
@@ -315,13 +318,15 @@ impl AnomalyDetector {
         let max_val = values.iter().fold(f32::NEG_INFINITY, |a, &b| a.max(b));
 
         if (max_val - min_val).abs() < 1e-10 {
-            return IsolationTree::Leaf { size: samples.len() };
+            return IsolationTree::Leaf {
+                size: samples.len(),
+            };
         }
 
         let split_value = random_f32(min_val, max_val);
 
-        let (left, right): (Vec<_>, Vec<_>) = samples.iter()
-            .partition(|s| s[feature] < split_value);
+        let (left, right): (Vec<_>, Vec<_>) =
+            samples.iter().partition(|s| s[feature] < split_value);
 
         IsolationTree::Internal {
             feature,
@@ -332,7 +337,8 @@ impl AnomalyDetector {
     }
 
     fn compute_path_length(&self, trees: &[IsolationTree], sample: &[f32]) -> f64 {
-        let total: f64 = trees.iter()
+        let total: f64 = trees
+            .iter()
             .map(|tree| self.path_length(tree, sample, 0))
             .sum();
         total / trees.len() as f64
@@ -340,16 +346,19 @@ impl AnomalyDetector {
 
     fn path_length(&self, tree: &IsolationTree, sample: &[f32], depth: usize) -> f64 {
         match tree {
-            IsolationTree::Leaf { size } => {
-                depth as f64 + c_factor(*size)
-            }
-            IsolationTree::Internal { feature, split_value, left, right } => {
+            IsolationTree::Leaf { size } => depth as f64 + c_factor(*size),
+            IsolationTree::Internal {
+                feature,
+                split_value,
+                left,
+                right,
+            } => {
                 if (sample[*feature] as f64) < *split_value {
                     self.path_length(left, sample, depth + 1)
                 } else {
                     self.path_length(right, sample, depth + 1)
                 }
-            }
+            },
         }
     }
 
@@ -411,26 +420,37 @@ impl AnomalyDetector {
             })
             .collect();
 
-        let q1: Vec<f64> = sorted_values.iter()
+        let q1: Vec<f64> = sorted_values
+            .iter()
             .map(|vals| vals[vals.len() / 4])
             .collect();
 
-        let q3: Vec<f64> = sorted_values.iter()
+        let q3: Vec<f64> = sorted_values
+            .iter()
             .map(|vals| vals[vals.len() * 3 / 4])
             .collect();
 
-        Ok(StatisticalModel { mean, std, min, max, q1, q3 })
+        Ok(StatisticalModel {
+            mean,
+            std,
+            min,
+            max,
+            q1,
+            q3,
+        })
     }
 
     /// Detect anomalies in a single vector
     pub fn detect(&self, vector_id: &str, vector: &[f32]) -> Result<DetectionResult> {
         self.stats.total_samples.fetch_add(1, Ordering::Relaxed);
 
-        let model = self.model.read()
+        let model = self
+            .model
+            .read()
             .map_err(|_| VecStoreError::LockError("model lock poisoned".into()))?;
-        let model = model.as_ref().ok_or({
-            VecStoreError::IndexNotInitialized
-        })?;
+        let model = model
+            .as_ref()
+            .ok_or({ VecStoreError::IndexNotInitialized })?;
 
         let (score, method_scores) = match model {
             DetectorModel::IsolationForest(m) => {
@@ -439,19 +459,19 @@ impl AnomalyDetector {
                 let mut scores = HashMap::new();
                 scores.insert("isolation_forest".to_string(), score);
                 (score, scores)
-            }
+            },
             DetectorModel::LOF(m) => {
                 let score = self.compute_lof_score(m, vector);
                 let mut scores = HashMap::new();
                 scores.insert("lof".to_string(), score);
                 (score, scores)
-            }
+            },
             DetectorModel::Statistical(m) => {
                 let score = self.compute_statistical_score(m, vector);
                 let mut scores = HashMap::new();
                 scores.insert("statistical".to_string(), score);
                 (score, scores)
-            }
+            },
             DetectorModel::Ensemble(detectors) => {
                 let mut scores = HashMap::new();
                 let mut total = 0.0;
@@ -460,16 +480,22 @@ impl AnomalyDetector {
                     scores.insert(detector.name().to_string(), s);
                     total += s;
                 }
-                let avg = if detectors.is_empty() { 0.0 } else { total / detectors.len() as f64 };
+                let avg = if detectors.is_empty() {
+                    0.0
+                } else {
+                    total / detectors.len() as f64
+                };
                 (avg, scores)
-            }
+            },
         };
 
         let is_anomaly = score >= self.config.alert_threshold;
         let confidence = self.compute_confidence(score);
 
         if is_anomaly {
-            self.stats.anomalies_detected.fetch_add(1, Ordering::Relaxed);
+            self.stats
+                .anomalies_detected
+                .fetch_add(1, Ordering::Relaxed);
 
             // Record anomaly
             let record = AnomalyRecord {
@@ -482,7 +508,8 @@ impl AnomalyDetector {
                 explanation: self.generate_explanation(model, vector, score),
             };
 
-            self.anomalies.write()
+            self.anomalies
+                .write()
                 .map_err(|_| VecStoreError::LockError("anomalies lock poisoned".into()))?
                 .push(record);
         }
@@ -541,17 +568,16 @@ impl AnomalyDetector {
         }
 
         // Find k nearest neighbors
-        let mut distances: Vec<(usize, f64)> = model.samples.iter()
+        let mut distances: Vec<(usize, f64)> = model
+            .samples
+            .iter()
             .enumerate()
             .map(|(i, s)| (i, euclidean_distance(sample, s)))
             .collect();
 
         distances.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap());
 
-        let k_neighbors: Vec<usize> = distances.iter()
-            .take(model.k)
-            .map(|(i, _)| *i)
-            .collect();
+        let k_neighbors: Vec<usize> = distances.iter().take(model.k).map(|(i, _)| *i).collect();
 
         // Compute local reachability density
         let k_dist = distances[model.k.min(distances.len() - 1)].1;
@@ -561,12 +587,7 @@ impl AnomalyDetector {
         let mut lof = 0.0;
         for &neighbor_idx in &k_neighbors {
             let neighbor = &model.samples[neighbor_idx];
-            let neighbor_lrd = self.compute_lrd(
-                model,
-                neighbor,
-                &k_neighbors,
-                k_dist
-            );
+            let neighbor_lrd = self.compute_lrd(model, neighbor, &k_neighbors, k_dist);
             if lrd > 0.0 {
                 lof += neighbor_lrd / lrd;
             }
@@ -575,7 +596,13 @@ impl AnomalyDetector {
         lof / k_neighbors.len() as f64
     }
 
-    fn compute_lrd(&self, _model: &LOFModel, _sample: &[f32], _neighbors: &[usize], k_dist: f64) -> f64 {
+    fn compute_lrd(
+        &self,
+        _model: &LOFModel,
+        _sample: &[f32],
+        _neighbors: &[usize],
+        k_dist: f64,
+    ) -> f64 {
         // Simplified LRD computation
         if k_dist > 0.0 { 1.0 / k_dist } else { 1.0 }
     }
@@ -622,7 +649,8 @@ impl AnomalyDetector {
     fn find_contributing_features(&self, model: &DetectorModel, sample: &[f32]) -> Vec<usize> {
         match model {
             DetectorModel::Statistical(m) => {
-                let mut contributions: Vec<(usize, f64)> = sample.iter()
+                let mut contributions: Vec<(usize, f64)> = sample
+                    .iter()
                     .enumerate()
                     .filter_map(|(i, &val)| {
                         if m.std[i] > 0.0 {
@@ -636,7 +664,7 @@ impl AnomalyDetector {
 
                 contributions.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
                 contributions.iter().take(5).map(|(i, _)| *i).collect()
-            }
+            },
             _ => vec![],
         }
     }
@@ -645,22 +673,31 @@ impl AnomalyDetector {
     fn generate_explanation(&self, model: &DetectorModel, sample: &[f32], score: f64) -> String {
         match model {
             DetectorModel::IsolationForest(_) => {
-                format!("Isolation score {:.3}: Vector is isolated from normal distribution", score)
-            }
+                format!(
+                    "Isolation score {:.3}: Vector is isolated from normal distribution",
+                    score
+                )
+            },
             DetectorModel::LOF(_) => {
-                format!("LOF score {:.3}: Vector has low local density compared to neighbors", score)
-            }
+                format!(
+                    "LOF score {:.3}: Vector has low local density compared to neighbors",
+                    score
+                )
+            },
             DetectorModel::Statistical(_m) => {
                 let features = self.find_contributing_features(model, sample);
                 if features.is_empty() {
-                    format!("Statistical score {:.3}: Overall deviation from normal", score)
+                    format!(
+                        "Statistical score {:.3}: Overall deviation from normal",
+                        score
+                    )
                 } else {
                     format!(
                         "Statistical score {:.3}: High deviation in dimensions {:?}",
                         score, features
                     )
                 }
-            }
+            },
             _ => format!("Anomaly score {:.3}", score),
         }
     }
@@ -675,17 +712,23 @@ impl AnomalyDetector {
             detection_rate: {
                 let total = self.stats.total_samples.load(Ordering::Relaxed);
                 let anomalies = self.stats.anomalies_detected.load(Ordering::Relaxed);
-                if total > 0 { anomalies as f64 / total as f64 } else { 0.0 }
+                if total > 0 {
+                    anomalies as f64 / total as f64
+                } else {
+                    0.0
+                }
             },
             last_training: {
-                let Ok(guard) = self.stats.last_training.read() else { return DetectionStats {
-                    total_samples: self.stats.total_samples.load(Ordering::Relaxed),
-                    anomalies_detected: self.stats.anomalies_detected.load(Ordering::Relaxed),
-                    false_positives: self.stats.false_positives.load(Ordering::Relaxed),
-                    true_positives: self.stats.true_positives.load(Ordering::Relaxed),
-                    detection_rate: 0.0,
-                    last_training: None,
-                }; };
+                let Ok(guard) = self.stats.last_training.read() else {
+                    return DetectionStats {
+                        total_samples: self.stats.total_samples.load(Ordering::Relaxed),
+                        anomalies_detected: self.stats.anomalies_detected.load(Ordering::Relaxed),
+                        false_positives: self.stats.false_positives.load(Ordering::Relaxed),
+                        true_positives: self.stats.true_positives.load(Ordering::Relaxed),
+                        detection_rate: 0.0,
+                        last_training: None,
+                    };
+                };
                 guard.map(|t| t.elapsed())
             },
         }
@@ -693,12 +736,10 @@ impl AnomalyDetector {
 
     /// Get recent anomalies
     pub fn get_recent_anomalies(&self, limit: usize) -> Vec<AnomalyRecord> {
-        let Ok(anomalies) = self.anomalies.read() else { return vec![]; };
-        anomalies.iter()
-            .rev()
-            .take(limit)
-            .cloned()
-            .collect()
+        let Ok(anomalies) = self.anomalies.read() else {
+            return vec![];
+        };
+        anomalies.iter().rev().take(limit).cloned().collect()
     }
 
     /// Provide feedback on detection
@@ -712,7 +753,9 @@ impl AnomalyDetector {
 
     /// Online update with new sample
     pub fn update(&self, vector: &[f32]) -> Result<()> {
-        let mut history = self.history.write()
+        let mut history = self
+            .history
+            .write()
             .map_err(|_| VecStoreError::LockError("history lock poisoned".into()))?;
 
         if history.len() >= self.config.window_size {
@@ -832,14 +875,17 @@ impl DriftDetector {
     /// Set reference distribution from data
     pub fn set_reference(&self, vectors: &[Vec<f32>]) -> Result<()> {
         let stats = self.compute_distribution_stats(vectors)?;
-        *self.reference_distribution.write()
-            .map_err(|_| VecStoreError::LockError("reference_distribution lock poisoned".into()))? = Some(stats);
+        *self.reference_distribution.write().map_err(|_| {
+            VecStoreError::LockError("reference_distribution lock poisoned".into())
+        })? = Some(stats);
         Ok(())
     }
 
     /// Add sample to detection window
     pub fn add_sample(&self, vector: Vec<f32>) -> Option<DriftEvent> {
-        let Ok(mut window) = self.current_window.write() else { return None; };
+        let Ok(mut window) = self.current_window.write() else {
+            return None;
+        };
         window.push_back(vector);
 
         if window.len() > self.config.detection_size {
@@ -859,7 +905,9 @@ impl DriftDetector {
 
     /// Check for drift
     fn check_drift(&self, current_samples: &[Vec<f32>]) -> Result<Option<DriftEvent>> {
-        let reference = self.reference_distribution.read()
+        let reference = self
+            .reference_distribution
+            .read()
             .map_err(|_| VecStoreError::LockError("reference_distribution lock poisoned".into()))?;
         let reference = match reference.as_ref() {
             Some(r) => r,
@@ -891,7 +939,8 @@ impl DriftDetector {
                 ),
             };
 
-            self.drift_events.write()
+            self.drift_events
+                .write()
                 .map_err(|_| VecStoreError::LockError("drift_events lock poisoned".into()))?
                 .push(event.clone());
             return Ok(Some(event));
@@ -999,7 +1048,8 @@ impl DriftDetector {
         let mut total_dist = 0.0;
 
         for (ref_q, curr_q) in ref_stats.quantiles.iter().zip(curr_stats.quantiles.iter()) {
-            let dist: f64 = ref_q.iter()
+            let dist: f64 = ref_q
+                .iter()
                 .zip(curr_q.iter())
                 .map(|(r, c)| (r - c).abs())
                 .sum();
@@ -1056,7 +1106,9 @@ impl DriftDetector {
 
     /// Get recent drift events
     pub fn get_drift_events(&self, limit: usize) -> Vec<DriftEvent> {
-        let Ok(events) = self.drift_events.read() else { return vec![]; };
+        let Ok(events) = self.drift_events.read() else {
+            return vec![];
+        };
         events.iter().rev().take(limit).cloned().collect()
     }
 }
@@ -1118,9 +1170,11 @@ fn current_timestamp() -> u64 {
 }
 
 fn random_usize(min: usize, max: usize) -> usize {
-    if max <= min { return min; }
-    use std::hash::{Hash, Hasher};
+    if max <= min {
+        return min;
+    }
     use std::collections::hash_map::DefaultHasher;
+    use std::hash::{Hash, Hasher};
     let mut hasher = DefaultHasher::new();
     Instant::now().hash(&mut hasher);
     let hash = hasher.finish();
@@ -1128,8 +1182,8 @@ fn random_usize(min: usize, max: usize) -> usize {
 }
 
 fn random_f32(min: f32, max: f32) -> f32 {
-    use std::hash::{Hash, Hasher};
     use std::collections::hash_map::DefaultHasher;
+    use std::hash::{Hash, Hasher};
     let mut hasher = DefaultHasher::new();
     Instant::now().hash(&mut hasher);
     let hash = hasher.finish();
@@ -1145,7 +1199,9 @@ fn euclidean_distance(a: &[f32], b: &[f32]) -> f64 {
 }
 
 fn percentile(values: &[f64], p: f64) -> f64 {
-    if values.is_empty() { return 0.0; }
+    if values.is_empty() {
+        return 0.0;
+    }
     let mut sorted = values.to_vec();
     sorted.sort_by(|a, b| a.partial_cmp(b).unwrap());
     let idx = ((sorted.len() as f64 - 1.0) * p) as usize;
@@ -1153,14 +1209,18 @@ fn percentile(values: &[f64], p: f64) -> f64 {
 }
 
 fn c_factor(size: usize) -> f64 {
-    if size <= 1 { return 0.0; }
+    if size <= 1 {
+        return 0.0;
+    }
     let n = size as f64;
     2.0 * ((n - 1.0).ln() + 0.5772156649) - (2.0 * (n - 1.0) / n)
 }
 
 fn anomaly_score(path_length: f64, sample_size: usize) -> f64 {
     let c = c_factor(sample_size);
-    if c == 0.0 { return 0.5; }
+    if c == 0.0 {
+        return 0.5;
+    }
     (2.0_f64).powf(-path_length / c)
 }
 
@@ -1205,9 +1265,7 @@ mod tests {
             .build();
 
         // Generate normal data
-        let normal_data: Vec<Vec<f32>> = (0..100)
-            .map(|_| vec![0.5, 0.5, 0.5])
-            .collect();
+        let normal_data: Vec<Vec<f32>> = (0..100).map(|_| vec![0.5, 0.5, 0.5]).collect();
 
         detector.fit(&normal_data).unwrap();
 
@@ -1224,9 +1282,7 @@ mod tests {
     fn test_drift_detector() {
         let detector = DriftDetector::new(DriftConfig::default());
 
-        let reference: Vec<Vec<f32>> = (0..100)
-            .map(|_| vec![0.5, 0.5, 0.5])
-            .collect();
+        let reference: Vec<Vec<f32>> = (0..100).map(|_| vec![0.5, 0.5, 0.5]).collect();
 
         detector.set_reference(&reference).unwrap();
     }
diff --git a/src/async_ops.rs b/src/async_ops.rs
index 2036851..aba22dd 100644
--- a/src/async_ops.rs
+++ b/src/async_ops.rs
@@ -107,9 +107,9 @@ impl AsyncStoreOps {
         for chunk in chunks {
             let store_clone = self.store.clone();
             let handle = task::spawn_blocking(move || {
-                let mut store = store_clone
-                    .lock()
-                    .map_err(|_| VecStoreError::LockError("failed to acquire store lock for batch upsert".into()))?;
+                let mut store = store_clone.lock().map_err(|_| {
+                    VecStoreError::LockError("failed to acquire store lock for batch upsert".into())
+                })?;
                 for (id, vector, metadata) in chunk {
                     let metadata: Metadata = serde_json::from_value(metadata)?;
                     store.upsert(id, vector, metadata)?;
@@ -158,9 +158,9 @@ impl AsyncStoreOps {
         for query_vec in queries {
             let store_clone = self.store.clone();
             let handle = task::spawn_blocking(move || {
-                let store = store_clone
-                    .lock()
-                    .map_err(|_| VecStoreError::LockError("failed to acquire store lock for batch query".into()))?;
+                let store = store_clone.lock().map_err(|_| {
+                    VecStoreError::LockError("failed to acquire store lock for batch query".into())
+                })?;
                 let query = Query::new(query_vec).with_limit(k);
                 store.query(query)
             });
@@ -183,9 +183,9 @@ impl AsyncStoreOps {
         for id in ids {
             let store_clone = self.store.clone();
             let handle = task::spawn_blocking(move || {
-                let mut store = store_clone
-                    .lock()
-                    .map_err(|_| VecStoreError::LockError("failed to acquire store lock for batch delete".into()))?;
+                let mut store = store_clone.lock().map_err(|_| {
+                    VecStoreError::LockError("failed to acquire store lock for batch delete".into())
+                })?;
                 store.delete(&id)
             });
             handles.push(handle);
diff --git a/src/async_stream.rs b/src/async_stream.rs
index e9ae92d..edf484b 100644
--- a/src/async_stream.rs
+++ b/src/async_stream.rs
@@ -273,14 +273,14 @@ impl Stream for ProgressiveQueryStream {
                 match &event {
                     StreamEvent::Result(_) => {
                         self.received += 1;
-                    }
+                    },
                     StreamEvent::Progress { total, .. } => {
                         self.total_expected = Some(*total);
-                    }
-                    _ => {}
+                    },
+                    _ => {},
                 }
                 Poll::Ready(Some(event))
-            }
+            },
             Poll::Ready(None) => Poll::Ready(None),
             Poll::Pending => Poll::Pending,
         }
@@ -402,7 +402,7 @@ mod tests {
             match event {
                 StreamEvent::Result(_) => result_count += 1,
                 StreamEvent::Done => got_done = true,
-                _ => {}
+                _ => {},
             }
         }
 
diff --git a/src/audit.rs b/src/audit.rs
index f975332..d68cc9d 100644
--- a/src/audit.rs
+++ b/src/audit.rs
@@ -63,8 +63,7 @@ pub enum AuditOutcome {
 }
 
 /// Audit entry metadata
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[derive(Default)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct AuditMetadata {
     /// User identifier
     pub user_id: Option<String>,
@@ -83,7 +82,6 @@ pub struct AuditMetadata {
     pub custom: std::collections::HashMap<String, serde_json::Value>,
 }
 
-
 /// Audit log entry
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AuditEntry {
@@ -226,13 +224,16 @@ impl MemoryBackend {
     }
 
     pub fn get_entries(&self) -> Result<Vec<AuditEntry>, VecStoreError> {
-        let entries = self.entries.lock()
+        let entries = self
+            .entries
+            .lock()
             .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?;
         Ok(entries.iter().cloned().collect())
     }
 
     pub fn clear(&self) -> Result<(), VecStoreError> {
-        self.entries.lock()
+        self.entries
+            .lock()
             .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?
             .clear();
         Ok(())
@@ -241,7 +242,9 @@ impl MemoryBackend {
 
 impl AuditBackend for MemoryBackend {
     fn write(&mut self, entry: &AuditEntry) -> Result<(), String> {
-        let mut entries = self.entries.lock()
+        let mut entries = self
+            .entries
+            .lock()
             .map_err(|_| "entries lock poisoned".to_string())?;
         if entries.len() >= self.max_size {
             entries.pop_front();
@@ -288,7 +291,9 @@ impl AuditBackend for FileBackend {
         let json = serde_json::to_string(entry)
             .map_err(|e| format!("Failed to serialize audit entry: {}", e))?;
 
-        let mut buffer = self.buffer.lock()
+        let mut buffer = self
+            .buffer
+            .lock()
             .map_err(|_| "buffer lock poisoned".to_string())?;
         buffer.push(json);
 
@@ -301,13 +306,17 @@ impl AuditBackend for FileBackend {
     }
 
     fn flush(&mut self) -> Result<(), String> {
-        let mut buffer = self.buffer.lock()
+        let mut buffer = self
+            .buffer
+            .lock()
             .map_err(|_| "buffer lock poisoned".to_string())?;
         if buffer.is_empty() {
             return Ok(());
         }
 
-        let mut file = self.file.lock()
+        let mut file = self
+            .file
+            .lock()
             .map_err(|_| "file lock poisoned".to_string())?;
 
         for line in buffer.iter() {
@@ -396,7 +405,8 @@ impl AuditLogger {
 
     /// Add a backend
     pub fn add_backend(&self, backend: Box<dyn AuditBackend>) -> Result<(), VecStoreError> {
-        self.backends.lock()
+        self.backends
+            .lock()
             .map_err(|_| VecStoreError::LockError("backends lock poisoned".into()))?
             .push(backend);
         Ok(())
@@ -421,7 +431,9 @@ impl AuditLogger {
         }
 
         // Write to all backends
-        let mut backends = self.backends.lock()
+        let mut backends = self
+            .backends
+            .lock()
             .map_err(|_| "backends lock poisoned".to_string())?;
         for backend in backends.iter_mut() {
             backend.write(&entry)?;
@@ -432,7 +444,9 @@ impl AuditLogger {
 
     /// Flush all backends
     pub fn flush(&self) -> Result<(), String> {
-        let mut backends = self.backends.lock()
+        let mut backends = self
+            .backends
+            .lock()
             .map_err(|_| "backends lock poisoned".to_string())?;
         for backend in backends.iter_mut() {
             backend.flush()?;
diff --git a/src/auto_tune.rs b/src/auto_tune.rs
index de92e6b..e4dab19 100644
--- a/src/auto_tune.rs
+++ b/src/auto_tune.rs
@@ -35,7 +35,7 @@
 //! println!("Optimal params: {:?}", params);
 //! ```
 
-use anyhow::{Result};
+use anyhow::Result;
 use rand::Rng;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -193,15 +193,13 @@ impl Default for HybridParams {
 }
 
 /// Combined index parameters
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[derive(Default)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct IndexParams {
     pub hnsw: HNSWParams,
     pub ivf: IVFParams,
     pub hybrid: HybridParams,
 }
 
-
 // ============================================================================
 // EVALUATION METRICS
 // ============================================================================
@@ -367,7 +365,9 @@ impl AutoTuner {
         F: FnMut(&IndexParams, &[f32], usize) -> Result<(Vec<String>, std::time::Duration)>,
     {
         if queries.len() != ground_truth.len() {
-            return Err(anyhow::anyhow!("Queries and ground truth must have same length"));
+            return Err(anyhow::anyhow!(
+                "Queries and ground truth must have same length"
+            ));
         }
 
         let k = ground_truth.first().map(|g| g.len()).unwrap_or(10);
@@ -382,7 +382,8 @@ impl AutoTuner {
             };
 
             // Evaluate
-            let eval = self.evaluate(&candidate_params, queries, ground_truth, k, &mut search_fn)?;
+            let eval =
+                self.evaluate(&candidate_params, queries, ground_truth, k, &mut search_fn)?;
 
             // Record observation
             self.optimizer.observe(param_vec.clone(), eval.score);
@@ -403,7 +404,15 @@ impl AutoTuner {
             }
 
             // Update best params
-            if eval.score > self.score_params(&self.current_params, queries, ground_truth, k, &mut search_fn)? {
+            if eval.score
+                > self.score_params(
+                    &self.current_params,
+                    queries,
+                    ground_truth,
+                    k,
+                    &mut search_fn,
+                )?
+            {
                 self.current_params = eval.params;
             }
         }
@@ -440,10 +449,7 @@ impl AutoTuner {
             latencies.push(duration.as_secs_f64() * 1000.0);
 
             // Calculate recall
-            let hits = results
-                .iter()
-                .filter(|r| truth.contains(r))
-                .count();
+            let hits = results.iter().filter(|r| truth.contains(r)).count();
             total_recall += hits as f32 / k as f32;
         }
 
@@ -453,7 +459,10 @@ impl AutoTuner {
         // Calculate latency statistics
         latencies.sort_by(|a, b| a.total_cmp(b));
         let latency_ms = latencies.iter().sum::<f64>() / latencies.len() as f64;
-        let latency_p99_ms = latencies.get(latencies.len() * 99 / 100).copied().unwrap_or(0.0);
+        let latency_p99_ms = latencies
+            .get(latencies.len() * 99 / 100)
+            .copied()
+            .unwrap_or(0.0);
         let qps = 1000.0 / latency_ms;
 
         // Compute score (balance recall and latency)
diff --git a/src/auto_tuning.rs b/src/auto_tuning.rs
index e526de2..d00be45 100644
--- a/src/auto_tuning.rs
+++ b/src/auto_tuning.rs
@@ -1,11 +1,11 @@
 // Auto-Tuning Engine - Automated parameter optimization for vector indexes
 // Bayesian optimization, hyperparameter search, and adaptive configuration
 
+use std::cmp::Ordering as CmpOrdering;
 use std::collections::HashMap;
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::RwLock;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, Instant};
-use std::cmp::Ordering as CmpOrdering;
 
 use serde::{Deserialize, Serialize};
 
@@ -132,7 +132,12 @@ pub struct Parameter {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum ParameterType {
     /// Integer range
-    Integer { min: i64, max: i64, step: Option<i64>, log_scale: bool },
+    Integer {
+        min: i64,
+        max: i64,
+        step: Option<i64>,
+        log_scale: bool,
+    },
     /// Float range
     Float { min: f64, max: f64, log_scale: bool },
     /// Categorical choices
@@ -319,8 +324,13 @@ impl AutoTuner {
 
             let params = self.sample_random();
             let _result = self.evaluate_trial(&params, &objective_fn)?;
-            improvement_history.push(*self.stats.best_objective.read()
-                .map_err(|_| VecStoreError::LockError("best_objective lock poisoned".into()))?);
+            improvement_history.push(
+                *self
+                    .stats
+                    .best_objective
+                    .read()
+                    .map_err(|_| VecStoreError::LockError("best_objective lock poisoned".into()))?,
+            );
         }
 
         // Main optimization loop
@@ -341,10 +351,16 @@ impl AutoTuner {
                 SearchStrategy::PopulationBasedTraining => self.sample_random(),
             };
 
-            let prev_best = *self.stats.best_objective.read()
+            let prev_best = *self
+                .stats
+                .best_objective
+                .read()
                 .map_err(|_| VecStoreError::LockError("best_objective lock poisoned".into()))?;
             let _result = self.evaluate_trial(&params, &objective_fn)?;
-            let new_best = *self.stats.best_objective.read()
+            let new_best = *self
+                .stats
+                .best_objective
+                .read()
                 .map_err(|_| VecStoreError::LockError("best_objective lock poisoned".into()))?;
 
             improvement_history.push(new_best);
@@ -361,19 +377,30 @@ impl AutoTuner {
         }
 
         let total_time = start.elapsed();
-        *self.stats.total_time.write()
+        *self
+            .stats
+            .total_time
+            .write()
             .map_err(|_| VecStoreError::LockError("total_time lock poisoned".into()))? = total_time;
 
-        let trials = self.trials.read()
-            .map_err(|_| VecStoreError::LockError("trials lock poisoned".into()))?.clone();
-        let best_trial = self.best_trial.read()
-            .map_err(|_| VecStoreError::LockError("best_trial lock poisoned".into()))?.clone();
+        let trials = self
+            .trials
+            .read()
+            .map_err(|_| VecStoreError::LockError("trials lock poisoned".into()))?
+            .clone();
+        let best_trial = self
+            .best_trial
+            .read()
+            .map_err(|_| VecStoreError::LockError("best_trial lock poisoned".into()))?
+            .clone();
 
         Ok(TuneResult {
-            best_params: best_trial.as_ref()
+            best_params: best_trial
+                .as_ref()
                 .map(|t| t.params.clone())
                 .unwrap_or_default(),
-            best_objective: best_trial.as_ref()
+            best_objective: best_trial
+                .as_ref()
                 .and_then(|t| t.objective)
                 .unwrap_or(f64::NEG_INFINITY),
             trials,
@@ -417,32 +444,38 @@ impl AutoTuner {
                 self.stats.completed_trials.fetch_add(1, Ordering::Relaxed);
 
                 // Update best
-                let current_best = *self.stats.best_objective.read()
-                    .map_err(|_| VecStoreError::LockError("best_objective lock poisoned".into()))?;
+                let current_best =
+                    *self.stats.best_objective.read().map_err(|_| {
+                        VecStoreError::LockError("best_objective lock poisoned".into())
+                    })?;
                 let is_better = match self.config.direction {
                     OptimizeDirection::Maximize => objective > current_best,
                     OptimizeDirection::Minimize => objective < current_best,
                 };
 
                 if is_better {
-                    *self.stats.best_objective.write()
-                        .map_err(|_| VecStoreError::LockError("best_objective lock poisoned".into()))? = objective;
-                    *self.best_trial.write()
-                        .map_err(|_| VecStoreError::LockError("best_trial lock poisoned".into()))? = Some(trial.clone());
+                    *self.stats.best_objective.write().map_err(|_| {
+                        VecStoreError::LockError("best_objective lock poisoned".into())
+                    })? = objective;
+                    *self.best_trial.write().map_err(|_| {
+                        VecStoreError::LockError("best_trial lock poisoned".into())
+                    })? = Some(trial.clone());
                 }
 
                 // Update surrogate model
                 self.update_surrogate(&trial)?;
-            }
+            },
             Err(_) => {
                 trial.state = TrialState::Failed;
                 trial.duration = Some(start.elapsed());
                 self.stats.failed_trials.fetch_add(1, Ordering::Relaxed);
-            }
+            },
         }
 
-        self.trials.write()
-            .map_err(|_| VecStoreError::LockError("trials lock poisoned".into()))?.push(trial.clone());
+        self.trials
+            .write()
+            .map_err(|_| VecStoreError::LockError("trials lock poisoned".into()))?
+            .push(trial.clone());
         Ok(trial)
     }
 
@@ -452,7 +485,12 @@ impl AutoTuner {
 
         for param in &self.parameter_space.parameters {
             let value = match &param.param_type {
-                ParameterType::Integer { min, max, step, log_scale } => {
+                ParameterType::Integer {
+                    min,
+                    max,
+                    step,
+                    log_scale,
+                } => {
                     let val = if *log_scale {
                         let log_min = (*min as f64).ln();
                         let log_max = (*max as f64).ln();
@@ -467,8 +505,12 @@ impl AutoTuner {
                         val
                     };
                     ParameterValue::Integer(val.clamp(*min, *max))
-                }
-                ParameterType::Float { min, max, log_scale } => {
+                },
+                ParameterType::Float {
+                    min,
+                    max,
+                    log_scale,
+                } => {
                     let val = if *log_scale {
                         let log_min = min.ln();
                         let log_max = max.ln();
@@ -477,14 +519,12 @@ impl AutoTuner {
                         random_f64(*min, *max)
                     };
                     ParameterValue::Float(val)
-                }
+                },
                 ParameterType::Categorical { choices } | ParameterType::Ordinal { choices } => {
                     let idx = random_usize(0, choices.len());
                     ParameterValue::String(choices[idx].clone())
-                }
-                ParameterType::Boolean => {
-                    ParameterValue::Boolean(random_bool())
-                }
+                },
+                ParameterType::Boolean => ParameterValue::Boolean(random_bool()),
             };
             params.insert(param.name.clone(), value);
         }
@@ -506,24 +546,24 @@ impl AutoTuner {
                     let pos = idx % range;
                     idx /= range;
                     ParameterValue::Integer(*min + pos as i64)
-                }
+                },
                 ParameterType::Float { min, max, .. } => {
                     let steps = 10;
                     let pos = idx % steps;
                     idx /= steps;
                     let val = min + (max - min) * (pos as f64 / (steps - 1) as f64);
                     ParameterValue::Float(val)
-                }
+                },
                 ParameterType::Categorical { choices } | ParameterType::Ordinal { choices } => {
                     let pos = idx % choices.len();
                     idx /= choices.len();
                     ParameterValue::String(choices[pos].clone())
-                }
+                },
                 ParameterType::Boolean => {
                     let val = idx.is_multiple_of(2);
                     idx /= 2;
                     ParameterValue::Boolean(val)
-                }
+                },
             };
             params.insert(param.name.clone(), value);
         }
@@ -533,7 +573,9 @@ impl AutoTuner {
 
     /// Sample using Bayesian optimization
     fn sample_bayesian(&self) -> Result<HashMap<String, ParameterValue>> {
-        let trials = self.trials.read()
+        let trials = self
+            .trials
+            .read()
             .map_err(|_| VecStoreError::LockError("trials lock poisoned".into()))?;
 
         if trials.len() < self.config.n_initial_samples {
@@ -560,14 +602,19 @@ impl AutoTuner {
 
     /// Compute acquisition value for a point
     fn compute_acquisition(&self, params: &HashMap<String, ParameterValue>) -> Result<f64> {
-        let surrogate = self.surrogate_model.read()
+        let surrogate = self
+            .surrogate_model
+            .read()
             .map_err(|_| VecStoreError::LockError("surrogate_model lock poisoned".into()))?;
 
         if let Some(model) = surrogate.as_ref() {
             let x = self.params_to_vector(params);
             let (mean, std) = model.predict(&x);
 
-            let best_f = *self.stats.best_objective.read()
+            let best_f = *self
+                .stats
+                .best_objective
+                .read()
                 .map_err(|_| VecStoreError::LockError("best_objective lock poisoned".into()))?;
 
             // Expected Improvement
@@ -582,7 +629,9 @@ impl AutoTuner {
 
     /// Sample using TPE
     fn sample_tpe(&self) -> Result<HashMap<String, ParameterValue>> {
-        let trials = self.trials.read()
+        let trials = self
+            .trials
+            .read()
             .map_err(|_| VecStoreError::LockError("trials lock poisoned".into()))?;
 
         if trials.len() < self.config.n_initial_samples {
@@ -590,12 +639,12 @@ impl AutoTuner {
         }
 
         // Split trials into good and bad
-        let mut sorted_trials: Vec<_> = trials.iter()
-            .filter(|t| t.objective.is_some())
-            .collect();
+        let mut sorted_trials: Vec<_> = trials.iter().filter(|t| t.objective.is_some()).collect();
 
         sorted_trials.sort_by(|a, b| {
-            b.objective.unwrap().partial_cmp(&a.objective.unwrap())
+            b.objective
+                .unwrap()
+                .partial_cmp(&a.objective.unwrap())
                 .unwrap_or(CmpOrdering::Equal)
         });
 
@@ -608,10 +657,12 @@ impl AutoTuner {
         let mut params = HashMap::new();
 
         for param in &self.parameter_space.parameters {
-            let good_values: Vec<_> = good_trials.iter()
+            let good_values: Vec<_> = good_trials
+                .iter()
                 .filter_map(|t| t.params.get(&param.name))
                 .collect();
-            let bad_values: Vec<_> = bad_trials.iter()
+            let bad_values: Vec<_> = bad_trials
+                .iter()
                 .filter_map(|t| t.params.get(&param.name))
                 .collect();
 
@@ -633,13 +684,13 @@ impl AutoTuner {
             return match param_type {
                 ParameterType::Integer { min, max, .. } => {
                     ParameterValue::Integer(random_i64(*min, *max))
-                }
+                },
                 ParameterType::Float { min, max, .. } => {
                     ParameterValue::Float(random_f64(*min, *max))
-                }
+                },
                 ParameterType::Categorical { choices } | ParameterType::Ordinal { choices } => {
                     ParameterValue::String(choices[random_usize(0, choices.len())].clone())
-                }
+                },
                 ParameterType::Boolean => ParameterValue::Boolean(random_bool()),
             };
         }
@@ -650,7 +701,9 @@ impl AutoTuner {
 
     /// Sample using genetic algorithm
     fn sample_genetic(&self) -> Result<HashMap<String, ParameterValue>> {
-        let trials = self.trials.read()
+        let trials = self
+            .trials
+            .read()
             .map_err(|_| VecStoreError::LockError("trials lock poisoned".into()))?;
 
         if trials.len() < 2 {
@@ -658,12 +711,12 @@ impl AutoTuner {
         }
 
         // Select two parents from top trials
-        let mut sorted: Vec<_> = trials.iter()
-            .filter(|t| t.objective.is_some())
-            .collect();
+        let mut sorted: Vec<_> = trials.iter().filter(|t| t.objective.is_some()).collect();
 
         sorted.sort_by(|a, b| {
-            b.objective.unwrap().partial_cmp(&a.objective.unwrap())
+            b.objective
+                .unwrap()
+                .partial_cmp(&a.objective.unwrap())
                 .unwrap_or(CmpOrdering::Equal)
         });
 
@@ -692,7 +745,11 @@ impl AutoTuner {
         Ok(child)
     }
 
-    fn mutate_parameter(&self, param_type: &ParameterType, value: Option<ParameterValue>) -> ParameterValue {
+    fn mutate_parameter(
+        &self,
+        param_type: &ParameterType,
+        value: Option<ParameterValue>,
+    ) -> ParameterValue {
         match param_type {
             ParameterType::Integer { min, max, .. } => {
                 let base = match value {
@@ -701,7 +758,7 @@ impl AutoTuner {
                 };
                 let mutation = random_i64(-10, 10);
                 ParameterValue::Integer((base + mutation).clamp(*min, *max))
-            }
+            },
             ParameterType::Float { min, max, .. } => {
                 let base = match value {
                     Some(ParameterValue::Float(v)) => v,
@@ -709,10 +766,10 @@ impl AutoTuner {
                 };
                 let mutation = random_f64(-0.1, 0.1) * (max - min);
                 ParameterValue::Float((base + mutation).clamp(*min, *max))
-            }
+            },
             ParameterType::Categorical { choices } | ParameterType::Ordinal { choices } => {
                 ParameterValue::String(choices[random_usize(0, choices.len())].clone())
-            }
+            },
             ParameterType::Boolean => ParameterValue::Boolean(random_bool()),
         }
     }
@@ -721,7 +778,9 @@ impl AutoTuner {
     fn sample_annealing(&self, iteration: usize) -> Result<HashMap<String, ParameterValue>> {
         let temperature = 1.0 / (1.0 + iteration as f64 * 0.01);
 
-        let best = self.best_trial.read()
+        let best = self
+            .best_trial
+            .read()
             .map_err(|_| VecStoreError::LockError("best_trial lock poisoned".into()))?;
         if let Some(best_trial) = best.as_ref() {
             let mut params = best_trial.params.clone();
@@ -729,10 +788,8 @@ impl AutoTuner {
             // Perturb parameters based on temperature
             for param in &self.parameter_space.parameters {
                 if random_f64(0.0, 1.0) < temperature {
-                    let new_value = self.mutate_parameter(
-                        &param.param_type,
-                        params.get(&param.name).cloned(),
-                    );
+                    let new_value =
+                        self.mutate_parameter(&param.param_type, params.get(&param.name).cloned());
                     params.insert(param.name.clone(), new_value);
                 }
             }
@@ -752,7 +809,9 @@ impl AutoTuner {
         let x = self.params_to_vector(&trial.params);
         let y = trial.objective.unwrap();
 
-        let mut surrogate = self.surrogate_model.write()
+        let mut surrogate = self
+            .surrogate_model
+            .write()
             .map_err(|_| VecStoreError::LockError("surrogate_model lock poisoned".into()))?;
         if surrogate.is_none() {
             *surrogate = Some(SurrogateModel {
@@ -773,12 +832,20 @@ impl AutoTuner {
 
     /// Convert parameters to vector for surrogate model
     fn params_to_vector(&self, params: &HashMap<String, ParameterValue>) -> Vec<f64> {
-        self.parameter_space.parameters.iter()
+        self.parameter_space
+            .parameters
+            .iter()
             .map(|p| {
                 match params.get(&p.name) {
                     Some(ParameterValue::Integer(v)) => *v as f64,
                     Some(ParameterValue::Float(v)) => *v,
-                    Some(ParameterValue::Boolean(v)) => if *v { 1.0 } else { 0.0 },
+                    Some(ParameterValue::Boolean(v)) => {
+                        if *v {
+                            1.0
+                        } else {
+                            0.0
+                        }
+                    },
                     Some(ParameterValue::String(s)) => {
                         // Map categorical to index
                         if let ParameterType::Categorical { choices } = &p.param_type {
@@ -786,7 +853,7 @@ impl AutoTuner {
                         } else {
                             0.0
                         }
-                    }
+                    },
                     None => 0.0,
                 }
             })
@@ -817,7 +884,7 @@ impl AutoTuner {
                             params.insert(p2.clone(), temp.unwrap());
                         }
                     }
-                }
+                },
                 ConstraintType::GreaterThan(p1, p2) => {
                     if let (Some(v1), Some(v2)) = (params.get(p1), params.get(p2)) {
                         let v1_float = match v1 {
@@ -837,8 +904,8 @@ impl AutoTuner {
                             params.insert(p2.clone(), temp.unwrap());
                         }
                     }
-                }
-                _ => {}
+                },
+                _ => {},
             }
         }
     }
@@ -850,9 +917,15 @@ impl AutoTuner {
             completed_trials: self.stats.completed_trials.load(Ordering::Relaxed),
             failed_trials: self.stats.failed_trials.load(Ordering::Relaxed),
             pruned_trials: self.stats.pruned_trials.load(Ordering::Relaxed),
-            best_objective: *self.stats.best_objective.read()
+            best_objective: *self
+                .stats
+                .best_objective
+                .read()
                 .map_err(|_| VecStoreError::LockError("best_objective lock poisoned".into()))?,
-            total_time: *self.stats.total_time.read()
+            total_time: *self
+                .stats
+                .total_time
+                .read()
                 .map_err(|_| VecStoreError::LockError("total_time lock poisoned".into()))?,
         })
     }
@@ -883,7 +956,9 @@ impl SurrogateModel {
         };
 
         // Simple uncertainty estimate
-        let min_dist: f64 = self.observations.iter()
+        let min_dist: f64 = self
+            .observations
+            .iter()
             .map(|(obs_x, _)| self.compute_distance(x, obs_x))
             .fold(f64::INFINITY, f64::min);
 
@@ -930,32 +1005,45 @@ pub fn hnsw_parameter_space() -> ParameterSpace {
         parameters: vec![
             Parameter {
                 name: "m".to_string(),
-                param_type: ParameterType::Integer { min: 4, max: 64, step: Some(4), log_scale: false },
+                param_type: ParameterType::Integer {
+                    min: 4,
+                    max: 64,
+                    step: Some(4),
+                    log_scale: false,
+                },
                 description: "Number of connections per layer".to_string(),
                 default: ParameterValue::Integer(16),
             },
             Parameter {
                 name: "ef_construction".to_string(),
-                param_type: ParameterType::Integer { min: 50, max: 500, step: Some(50), log_scale: false },
+                param_type: ParameterType::Integer {
+                    min: 50,
+                    max: 500,
+                    step: Some(50),
+                    log_scale: false,
+                },
                 description: "Size of dynamic candidate list during construction".to_string(),
                 default: ParameterValue::Integer(100),
             },
             Parameter {
                 name: "ef_search".to_string(),
-                param_type: ParameterType::Integer { min: 10, max: 500, step: Some(10), log_scale: false },
+                param_type: ParameterType::Integer {
+                    min: 10,
+                    max: 500,
+                    step: Some(10),
+                    log_scale: false,
+                },
                 description: "Size of dynamic candidate list during search".to_string(),
                 default: ParameterValue::Integer(50),
             },
         ],
-        constraints: vec![
-            Constraint {
-                expression: "ef_construction >= ef_search".to_string(),
-                constraint_type: ConstraintType::GreaterThan(
-                    "ef_construction".to_string(),
-                    "ef_search".to_string(),
-                ),
-            },
-        ],
+        constraints: vec![Constraint {
+            expression: "ef_construction >= ef_search".to_string(),
+            constraint_type: ConstraintType::GreaterThan(
+                "ef_construction".to_string(),
+                "ef_search".to_string(),
+            ),
+        }],
     }
 }
 
@@ -965,26 +1053,31 @@ pub fn ivf_parameter_space() -> ParameterSpace {
         parameters: vec![
             Parameter {
                 name: "nlist".to_string(),
-                param_type: ParameterType::Integer { min: 16, max: 65536, step: None, log_scale: true },
+                param_type: ParameterType::Integer {
+                    min: 16,
+                    max: 65536,
+                    step: None,
+                    log_scale: true,
+                },
                 description: "Number of clusters".to_string(),
                 default: ParameterValue::Integer(100),
             },
             Parameter {
                 name: "nprobe".to_string(),
-                param_type: ParameterType::Integer { min: 1, max: 256, step: None, log_scale: false },
+                param_type: ParameterType::Integer {
+                    min: 1,
+                    max: 256,
+                    step: None,
+                    log_scale: false,
+                },
                 description: "Number of clusters to search".to_string(),
                 default: ParameterValue::Integer(8),
             },
         ],
-        constraints: vec![
-            Constraint {
-                expression: "nprobe <= nlist".to_string(),
-                constraint_type: ConstraintType::LessThan(
-                    "nprobe".to_string(),
-                    "nlist".to_string(),
-                ),
-            },
-        ],
+        constraints: vec![Constraint {
+            expression: "nprobe <= nlist".to_string(),
+            constraint_type: ConstraintType::LessThan("nprobe".to_string(), "nlist".to_string()),
+        }],
     }
 }
 
@@ -1029,12 +1122,19 @@ impl WorkloadAnalyzer {
     }
 
     /// Record a query
-    pub fn record_query(&self, latency_ms: f64, result_count: usize, filter_complexity: usize) -> Result<()> {
+    pub fn record_query(
+        &self,
+        latency_ms: f64,
+        result_count: usize,
+        filter_complexity: usize,
+    ) -> Result<()> {
         if random_f64(0.0, 1.0) > self.config.sample_rate {
             return Ok(());
         }
 
-        let mut queries = self.queries.write()
+        let mut queries = self
+            .queries
+            .write()
             .map_err(|_| VecStoreError::LockError("queries lock poisoned".into()))?;
         if queries.len() >= self.config.max_samples {
             queries.remove(0);
@@ -1051,7 +1151,9 @@ impl WorkloadAnalyzer {
 
     /// Analyze workload and recommend parameters
     pub fn recommend(&self) -> Result<WorkloadRecommendation> {
-        let queries = self.queries.read()
+        let queries = self
+            .queries
+            .read()
             .map_err(|_| VecStoreError::LockError("queries lock poisoned".into()))?;
 
         if queries.is_empty() {
@@ -1064,8 +1166,13 @@ impl WorkloadAnalyzer {
             });
         }
 
-        let avg_latency: f64 = queries.iter().map(|q| q.latency_ms).sum::<f64>() / queries.len() as f64;
-        let avg_filter_complexity: f64 = queries.iter().map(|q| q.filter_complexity as f64).sum::<f64>() / queries.len() as f64;
+        let avg_latency: f64 =
+            queries.iter().map(|q| q.latency_ms).sum::<f64>() / queries.len() as f64;
+        let avg_filter_complexity: f64 = queries
+            .iter()
+            .map(|q| q.filter_complexity as f64)
+            .sum::<f64>()
+            / queries.len() as f64;
 
         let latency_sensitive = avg_latency > 100.0;
         let filter_heavy = avg_filter_complexity > 2.0;
@@ -1099,8 +1206,8 @@ fn current_timestamp() -> u64 {
 }
 
 fn random_f64(min: f64, max: f64) -> f64 {
-    use std::hash::{Hash, Hasher};
     use std::collections::hash_map::DefaultHasher;
+    use std::hash::{Hash, Hasher};
 
     let mut hasher = DefaultHasher::new();
     Instant::now().hash(&mut hasher);
diff --git a/src/autotuning.rs b/src/autotuning.rs
index 9a126d9..c91eb3b 100644
--- a/src/autotuning.rs
+++ b/src/autotuning.rs
@@ -259,17 +259,17 @@ impl AutoTuner {
 
         // Adjust ef_construction and ef_search to meet recall constraints
         if let Some(recall) = params.estimated_recall
-            && recall < constraints.min_recall {
-                // Increase ef_search to improve recall
-                let recall_deficit = constraints.min_recall - recall;
-                let boost = 1.0 + recall_deficit * 2.0; // Heuristic
-                params.ef_search = (params.ef_search as f32 * boost) as usize;
-                params.ef_search = params.ef_search.min(500);
-
-                // Update estimated recall
-                params.estimated_recall =
-                    Some(params.estimated_recall.unwrap() + recall_deficit * 0.5);
-            }
+            && recall < constraints.min_recall
+        {
+            // Increase ef_search to improve recall
+            let recall_deficit = constraints.min_recall - recall;
+            let boost = 1.0 + recall_deficit * 2.0; // Heuristic
+            params.ef_search = (params.ef_search as f32 * boost) as usize;
+            params.ef_search = params.ef_search.min(500);
+
+            // Update estimated recall
+            params.estimated_recall = Some(params.estimated_recall.unwrap() + recall_deficit * 0.5);
+        }
 
         Ok(params)
     }
diff --git a/src/backpressure.rs b/src/backpressure.rs
index 4e07c4a..33243ad 100644
--- a/src/backpressure.rs
+++ b/src/backpressure.rs
@@ -33,7 +33,10 @@
 //! ```
 
 use std::collections::{HashMap, VecDeque};
-use std::sync::{Arc, RwLock, atomic::{AtomicU64, AtomicUsize, Ordering}};
+use std::sync::{
+    Arc, RwLock,
+    atomic::{AtomicU64, AtomicUsize, Ordering},
+};
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
 use serde::{Deserialize, Serialize};
@@ -218,7 +221,9 @@ impl BackpressureController {
 
     /// Check if should accept more records
     pub fn should_accept(&self) -> bool {
-        let Ok(state_guard) = self.state.read() else { return false; };
+        let Ok(state_guard) = self.state.read() else {
+            return false;
+        };
         let state = *state_guard;
 
         match state {
@@ -227,11 +232,11 @@ impl BackpressureController {
                 // Only accept if below low watermark
                 let fill_ratio = self.buffer_fill_ratio();
                 fill_ratio < self.config.low_watermark
-            }
+            },
             _ => {
                 // Accept if rate limiter allows
                 self.rate_limiter.try_acquire()
-            }
+            },
         }
     }
 
@@ -292,7 +297,9 @@ impl BackpressureController {
 
     /// Commit checkpoint
     pub fn commit_checkpoint(&self, offsets: HashMap<u32, u64>) {
-        let Ok(mut checkpoint) = self.checkpoint.write() else { return; };
+        let Ok(mut checkpoint) = self.checkpoint.write() else {
+            return;
+        };
         checkpoint.offsets = offsets;
         checkpoint.timestamp = unix_timestamp();
         checkpoint.pending_txns.clear();
@@ -327,9 +334,11 @@ impl BackpressureController {
             f64::INFINITY
         };
 
-        let partition_lag = self.partition_offsets.read()
+        let partition_lag = self
+            .partition_offsets
+            .read()
             .map(|guard| guard.clone())
-            .unwrap_or_default();  // Safe: returns empty HashMap on lock failure
+            .unwrap_or_default(); // Safe: returns empty HashMap on lock failure
 
         LagMetrics {
             pending_records: pending,
@@ -342,13 +351,15 @@ impl BackpressureController {
 
     /// Get current state
     pub fn get_state(&self) -> BackpressureState {
-        let Ok(state) = self.state.read() else { return BackpressureState::Normal; };
+        let Ok(state) = self.state.read() else {
+            return BackpressureState::Normal;
+        };
         *state
     }
 
     /// Get statistics
     pub fn get_stats(&self) -> StreamStats {
-        let dlq_size = self.dlq.read().map(|guard| guard.len()).unwrap_or(0);  // Safe: returns 0 on lock failure
+        let dlq_size = self.dlq.read().map(|guard| guard.len()).unwrap_or(0); // Safe: returns 0 on lock failure
         StreamStats {
             received: self.received.load(Ordering::Relaxed),
             processed: self.processed.load(Ordering::Relaxed),
@@ -362,7 +373,9 @@ impl BackpressureController {
 
     /// Get DLQ records
     pub fn get_dlq_records(&self, limit: usize) -> Vec<DeadLetterRecord> {
-        let Ok(dlq) = self.dlq.read() else { return Vec::new(); };
+        let Ok(dlq) = self.dlq.read() else {
+            return Vec::new();
+        };
         dlq.iter().take(limit).cloned().collect()
     }
 
@@ -386,12 +399,16 @@ impl BackpressureController {
     }
 
     fn calculate_processing_rate(&self) -> f64 {
-        let Ok(starts) = self.processing_starts.read() else { return 0.0; };
+        let Ok(starts) = self.processing_starts.read() else {
+            return 0.0;
+        };
         if starts.len() < 2 {
             return 0.0;
         }
 
-        let Some(oldest) = starts.front() else { return 0.0; };
+        let Some(oldest) = starts.front() else {
+            return 0.0;
+        };
         let elapsed = oldest.elapsed().as_secs_f64();
 
         if elapsed > 0.0 {
@@ -402,7 +419,9 @@ impl BackpressureController {
     }
 
     fn update_state(&self) {
-        let Ok(mut state) = self.state.write() else { return; };
+        let Ok(mut state) = self.state.write() else {
+            return;
+        };
 
         // Check circuit breaker
         if self.circuit_breaker.is_open() {
@@ -421,27 +440,29 @@ impl BackpressureController {
                 if fill_ratio >= self.config.high_watermark {
                     *state = BackpressureState::Backpressure;
                 }
-            }
+            },
             BackpressureState::Backpressure => {
                 if fill_ratio < self.config.low_watermark {
                     *state = BackpressureState::Normal;
                 }
-            }
+            },
             BackpressureState::CircuitOpen => {
                 if self.circuit_breaker.should_allow_request() {
                     *state = BackpressureState::Recovering;
                 }
-            }
+            },
             BackpressureState::Recovering => {
                 if !self.circuit_breaker.is_open() {
                     *state = BackpressureState::Normal;
                 }
-            }
+            },
         }
     }
 
     fn add_to_dlq<T: Serialize>(&self, record: &StreamRecord<T>, error: &str) {
-        let Ok(mut dlq) = self.dlq.write() else { return; };
+        let Ok(mut dlq) = self.dlq.write() else {
+            return;
+        };
 
         // Evict oldest if full
         while dlq.len() >= self.config.dlq_max_size {
@@ -507,19 +528,20 @@ impl RateLimiter {
             if current == 0 {
                 return false;
             }
-            if self.tokens.compare_exchange(
-                current,
-                current - 1,
-                Ordering::Relaxed,
-                Ordering::Relaxed,
-            ).is_ok() {
+            if self
+                .tokens
+                .compare_exchange(current, current - 1, Ordering::Relaxed, Ordering::Relaxed)
+                .is_ok()
+            {
                 return true;
             }
         }
     }
 
     fn refill(&self) {
-        let Ok(mut last) = self.last_refill.write() else { return; };
+        let Ok(mut last) = self.last_refill.write() else {
+            return;
+        };
         let elapsed = last.elapsed();
 
         if elapsed >= Duration::from_millis(100) {
@@ -566,7 +588,9 @@ impl CircuitBreaker {
     fn record_success(&self) {
         self.success_count.fetch_add(1, Ordering::Relaxed);
 
-        let Ok(mut state) = self.state.write() else { return; };
+        let Ok(mut state) = self.state.write() else {
+            return;
+        };
         if *state == CircuitState::HalfOpen {
             // Reset on success in half-open
             *state = CircuitState::Closed;
@@ -581,36 +605,44 @@ impl CircuitBreaker {
         }
 
         if count >= self.failure_threshold
-            && let Ok(mut state) = self.state.write() {
-                *state = CircuitState::Open;
-            }
+            && let Ok(mut state) = self.state.write()
+        {
+            *state = CircuitState::Open;
+        }
     }
 
     fn is_open(&self) -> bool {
-        let Ok(state_guard) = self.state.read() else { return true; };  // Fail-safe: treat as open
+        let Ok(state_guard) = self.state.read() else {
+            return true;
+        }; // Fail-safe: treat as open
         let state = *state_guard;
         drop(state_guard);
 
         match state {
             CircuitState::Open => {
                 // Check if timeout has passed
-                let Ok(last_failure_guard) = self.last_failure.read() else { return true; };
+                let Ok(last_failure_guard) = self.last_failure.read() else {
+                    return true;
+                };
                 if let Some(last) = *last_failure_guard
-                    && last.elapsed() > Duration::from_secs(self.timeout_seconds) {
-                        drop(last_failure_guard);
-                        if let Ok(mut state) = self.state.write() {
-                            *state = CircuitState::HalfOpen;
-                        }
-                        return false;
+                    && last.elapsed() > Duration::from_secs(self.timeout_seconds)
+                {
+                    drop(last_failure_guard);
+                    if let Ok(mut state) = self.state.write() {
+                        *state = CircuitState::HalfOpen;
                     }
+                    return false;
+                }
                 true
-            }
+            },
             _ => false,
         }
     }
 
     fn should_allow_request(&self) -> bool {
-        let Ok(state) = self.state.read() else { return false; };  // Fail-safe: deny requests on lock failure
+        let Ok(state) = self.state.read() else {
+            return false;
+        }; // Fail-safe: deny requests on lock failure
         *state != CircuitState::Open
     }
 }
@@ -640,7 +672,9 @@ impl<T: Clone + Serialize> BatchProcessor<T> {
 
         self.controller.record_received();
 
-        let Ok(mut buffer) = self.buffer.write() else { return false; };
+        let Ok(mut buffer) = self.buffer.write() else {
+            return false;
+        };
         buffer.push(record);
 
         true
@@ -648,13 +682,17 @@ impl<T: Clone + Serialize> BatchProcessor<T> {
 
     /// Check if batch is ready
     pub fn is_batch_ready(&self) -> bool {
-        let Ok(buffer) = self.buffer.read() else { return false; };
+        let Ok(buffer) = self.buffer.read() else {
+            return false;
+        };
         buffer.len() >= self.batch_size
     }
 
     /// Get batch for processing
     pub fn take_batch(&self) -> Vec<StreamRecord<T>> {
-        let Ok(mut buffer) = self.buffer.write() else { return Vec::new(); };
+        let Ok(mut buffer) = self.buffer.write() else {
+            return Vec::new();
+        };
         let batch: Vec<_> = buffer.drain(..).collect();
         batch
     }
diff --git a/src/backup.rs b/src/backup.rs
index 374de92..145602d 100644
--- a/src/backup.rs
+++ b/src/backup.rs
@@ -31,7 +31,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs::{self, File};
@@ -166,11 +166,7 @@ impl BackupManager {
         // Include milliseconds and a random suffix for uniqueness
         use rand::Rng;
         let random: u32 = rand::rng().random_range(0..10000);
-        format!(
-            "backup_{}_{}",
-            now.format("%Y%m%d_%H%M%S_%3f"),
-            random
-        )
+        format!("backup_{}_{}", now.format("%Y%m%d_%H%M%S_%3f"), random)
     }
 
     /// Create a backup of a VecStore directory
@@ -194,11 +190,7 @@ impl BackupManager {
         let mut total_size = 0u64;
 
         // Copy data files
-        let data_files = vec![
-            "manifest.json",
-            "records.bin",
-            "id_mapping.bin",
-        ];
+        let data_files = vec!["manifest.json", "records.bin", "id_mapping.bin"];
 
         for file in &data_files {
             let src = source.join(file);
@@ -319,7 +311,11 @@ impl BackupManager {
             let entry = entry?;
             let path = entry.path();
 
-            if path.is_file() && path.file_name().map(|n| n != "backup_info.json").unwrap_or(false)
+            if path.is_file()
+                && path
+                    .file_name()
+                    .map(|n| n != "backup_info.json")
+                    .unwrap_or(false)
             {
                 let mut file = File::open(&path)?;
                 let mut buffer = [0u8; 8192];
@@ -387,11 +383,7 @@ impl BackupManager {
     ///
     /// The target directory will be created if it doesn't exist.
     /// If it exists and is not empty, this will fail unless `force` is true.
-    pub fn restore_backup(
-        &self,
-        backup_id: &str,
-        target_path: impl AsRef<Path>,
-    ) -> Result<()> {
+    pub fn restore_backup(&self, backup_id: &str, target_path: impl AsRef<Path>) -> Result<()> {
         self.restore_backup_with_options(backup_id, target_path, false)
     }
 
@@ -621,7 +613,9 @@ mod walkdir {
         }
 
         pub fn file_type(&self) -> FileType {
-            FileType { is_file: self.is_file }
+            FileType {
+                is_file: self.is_file,
+            }
         }
     }
 
@@ -652,7 +646,7 @@ mod walkdir {
                             for e in entries.flatten() {
                                 self.stack.push(e.path());
                             }
-                        }
+                        },
                         Err(e) => return Some(Err(e)),
                     }
                 } else {
@@ -689,12 +683,18 @@ mod tests {
 
         // Create source with some files
         fs::create_dir_all(&source_dir).unwrap();
-        fs::write(source_dir.join("manifest.json"), r#"{"dimension":128,"record_count":100}"#).unwrap();
+        fs::write(
+            source_dir.join("manifest.json"),
+            r#"{"dimension":128,"record_count":100}"#,
+        )
+        .unwrap();
         fs::write(source_dir.join("records.bin"), vec![0u8; 1000]).unwrap();
 
         // Create backup
         let mgr = BackupManager::new(&backup_dir).unwrap();
-        let backup_id = mgr.create_backup(&source_dir, BackupConfig::default()).unwrap();
+        let backup_id = mgr
+            .create_backup(&source_dir, BackupConfig::default())
+            .unwrap();
 
         // Verify backup exists
         let backups = mgr.list_backups().unwrap();
@@ -719,10 +719,15 @@ mod tests {
         fs::write(source_dir.join("records.bin"), vec![1u8; 100]).unwrap();
 
         let mgr = BackupManager::new(&backup_dir).unwrap();
-        let backup_id = mgr.create_backup(&source_dir, BackupConfig {
-            verify: true,
-            ..Default::default()
-        }).unwrap();
+        let backup_id = mgr
+            .create_backup(
+                &source_dir,
+                BackupConfig {
+                    verify: true,
+                    ..Default::default()
+                },
+            )
+            .unwrap();
 
         // Verification should pass
         assert!(mgr.verify_backup(&backup_id).unwrap());
@@ -742,17 +747,31 @@ mod tests {
         // Create 3 backups with delay to ensure unique timestamps
         for i in 0..3 {
             let result = mgr.create_backup(&source_dir, BackupConfig::default());
-            assert!(result.is_ok(), "Failed to create backup {}: {:?}", i, result.err());
+            assert!(
+                result.is_ok(),
+                "Failed to create backup {}: {:?}",
+                i,
+                result.err()
+            );
             std::thread::sleep(std::time::Duration::from_millis(100));
         }
 
         let backups = mgr.list_backups().unwrap();
-        assert_eq!(backups.len(), 3, "Expected 3 backups, got {}", backups.len());
+        assert_eq!(
+            backups.len(),
+            3,
+            "Expected 3 backups, got {}",
+            backups.len()
+        );
 
         // Prune to keep only 1
         let deleted = mgr.prune(1).unwrap();
         assert_eq!(deleted.len(), 2, "Expected to delete 2 backups");
-        assert_eq!(mgr.list_backups().unwrap().len(), 1, "Expected 1 backup remaining");
+        assert_eq!(
+            mgr.list_backups().unwrap().len(),
+            1,
+            "Expected 1 backup remaining"
+        );
     }
 
     #[test]
@@ -775,7 +794,13 @@ mod tests {
         BackupArchive::extract_archive(&archive_path, &extract_dir).unwrap();
 
         // Verify
-        assert_eq!(fs::read_to_string(extract_dir.join("file1.txt")).unwrap(), "hello");
-        assert_eq!(fs::read(extract_dir.join("file2.bin")).unwrap(), vec![1, 2, 3, 4]);
+        assert_eq!(
+            fs::read_to_string(extract_dir.join("file1.txt")).unwrap(),
+            "hello"
+        );
+        assert_eq!(
+            fs::read(extract_dir.join("file2.bin")).unwrap(),
+            vec![1, 2, 3, 4]
+        );
     }
 }
diff --git a/src/benchmark.rs b/src/benchmark.rs
index ed717ec..10410e1 100644
--- a/src/benchmark.rs
+++ b/src/benchmark.rs
@@ -814,7 +814,10 @@ impl Benchmarker {
 
         // Calculate scalability factor
         let max_threads = multi_thread_qps.keys().max().copied().unwrap_or(1);
-        let max_qps = multi_thread_qps.get(&max_threads).copied().unwrap_or(single_thread_qps);
+        let max_qps = multi_thread_qps
+            .get(&max_threads)
+            .copied()
+            .unwrap_or(single_thread_qps);
         let scalability_factor = if single_thread_qps > 0.0 {
             (max_qps / single_thread_qps) / max_threads as f64
         } else {
diff --git a/src/bin/vecstore.rs b/src/bin/vecstore.rs
index d96e403..fdf12b2 100644
--- a/src/bin/vecstore.rs
+++ b/src/bin/vecstore.rs
@@ -3,9 +3,9 @@
 
 use anyhow::{Context, Result};
 use clap::{Parser, Subcommand, ValueEnum};
+use flate2::Compression;
 use flate2::read::GzDecoder;
 use flate2::write::GzEncoder;
-use flate2::Compression;
 use std::collections::HashMap;
 use std::fs::{self, File};
 use std::io::{BufReader, BufWriter};
@@ -315,7 +315,7 @@ fn main() -> Result<()> {
             } else {
                 println!("  Dimension will be auto-detected from first insert");
             }
-        }
+        },
 
         Commands::Ingest { dir, id, vec, meta } => {
             let mut store = VecStore::open(&dir)?;
@@ -335,7 +335,7 @@ fn main() -> Result<()> {
             store.save()?;
 
             println!("✓ Ingested record: {}", id);
-        }
+        },
 
         Commands::IngestBatch { dir, jsonl } => {
             let mut store = VecStore::open(&dir)?;
@@ -368,7 +368,7 @@ fn main() -> Result<()> {
                 elapsed.as_secs_f64(),
                 count as f64 / elapsed.as_secs_f64()
             );
-        }
+        },
 
         Commands::Query {
             dir,
@@ -417,7 +417,7 @@ fn main() -> Result<()> {
                     }
                 }
             }
-        }
+        },
 
         Commands::Stats { dir, detailed } => {
             let store = VecStore::open(&dir)?;
@@ -435,7 +435,7 @@ fn main() -> Result<()> {
                     (store.count() * store.dimension() * 4) / 1_048_576
                 );
             }
-        }
+        },
 
         Commands::Export {
             dir,
@@ -452,43 +452,47 @@ fn main() -> Result<()> {
                     let _lines: Vec<String> = Vec::new();
                     // Implementation would iterate and export
                     println!("✓ Exported to JSONL format");
-                }
+                },
                 ExportFormat::Csv => {
                     println!("✓ Exported to CSV format");
-                }
+                },
                 ExportFormat::Parquet => {
                     println!("✓ Exported to Parquet format");
-                }
+                },
                 ExportFormat::Npy => {
                     println!("✓ Exported to NumPy format");
-                }
+                },
             }
-        }
+        },
 
-        Commands::Import { dir: _, input, format } => {
+        Commands::Import {
+            dir: _,
+            input,
+            format,
+        } => {
             println!("Importing from {:?} ({:?} format)...", input, format);
 
             match format {
                 ImportFormat::Jsonl => {
                     println!("✓ Imported from JSONL");
-                }
+                },
                 ImportFormat::Csv => {
                     println!("✓ Imported from CSV");
-                }
+                },
                 ImportFormat::Npy => {
                     println!("✓ Imported from NumPy");
-                }
+                },
                 ImportFormat::Pinecone => {
                     println!("✓ Imported from Pinecone export");
-                }
+                },
                 ImportFormat::Weaviate => {
                     println!("✓ Imported from Weaviate export");
-                }
+                },
                 ImportFormat::Qdrant => {
                     println!("✓ Imported from Qdrant export");
-                }
+                },
             }
-        }
+        },
 
         Commands::Migrate {
             source,
@@ -503,25 +507,25 @@ fn main() -> Result<()> {
                 MigrationSource::Pinecone => {
                     println!("   Connecting to Pinecone...");
                     println!("✓ Migration complete!");
-                }
+                },
                 MigrationSource::Weaviate => {
                     println!("   Connecting to Weaviate...");
                     println!("✓ Migration complete!");
-                }
+                },
                 MigrationSource::Qdrant => {
                     println!("   Connecting to Qdrant...");
                     println!("✓ Migration complete!");
-                }
+                },
                 MigrationSource::ChromaDB => {
                     println!("   Connecting to ChromaDB...");
                     println!("✓ Migration complete!");
-                }
+                },
                 MigrationSource::Milvus => {
                     println!("   Connecting to Milvus...");
                     println!("✓ Migration complete!");
-                }
+                },
             }
-        }
+        },
 
         Commands::Backup {
             dir,
@@ -545,7 +549,9 @@ fn main() -> Result<()> {
 
             // Determine output path with proper extension
             let output_path = if compress {
-                if !output.to_string_lossy().ends_with(".tar.gz") && !output.to_string_lossy().ends_with(".tgz") {
+                if !output.to_string_lossy().ends_with(".tar.gz")
+                    && !output.to_string_lossy().ends_with(".tgz")
+                {
                     output.with_extension("tar.gz")
                 } else {
                     output.clone()
@@ -587,15 +593,20 @@ fn main() -> Result<()> {
                         file_count += 1;
 
                         let mut f = File::open(path)?;
-                        archive.append_file(relative_path, &mut f)
-                            .with_context(|| format!("Failed to add file to archive: {:?}", path))?;
+                        archive
+                            .append_file(relative_path, &mut f)
+                            .with_context(|| {
+                                format!("Failed to add file to archive: {:?}", path)
+                            })?;
                     } else if path.is_dir() && path != dir {
-                        archive.append_dir(relative_path, path)
-                            .with_context(|| format!("Failed to add directory to archive: {:?}", path))?;
+                        archive.append_dir(relative_path, path).with_context(|| {
+                            format!("Failed to add directory to archive: {:?}", path)
+                        })?;
                     }
                 }
 
-                archive.finish()
+                archive
+                    .finish()
                     .context("Failed to finalize backup archive")?;
             } else {
                 println!("   Compression: disabled");
@@ -611,15 +622,20 @@ fn main() -> Result<()> {
                         file_count += 1;
 
                         let mut f = File::open(path)?;
-                        archive.append_file(relative_path, &mut f)
-                            .with_context(|| format!("Failed to add file to archive: {:?}", path))?;
+                        archive
+                            .append_file(relative_path, &mut f)
+                            .with_context(|| {
+                                format!("Failed to add file to archive: {:?}", path)
+                            })?;
                     } else if path.is_dir() && path != dir {
-                        archive.append_dir(relative_path, path)
-                            .with_context(|| format!("Failed to add directory to archive: {:?}", path))?;
+                        archive.append_dir(relative_path, path).with_context(|| {
+                            format!("Failed to add directory to archive: {:?}", path)
+                        })?;
                     }
                 }
 
-                archive.finish()
+                archive
+                    .finish()
                     .context("Failed to finalize backup archive")?;
             }
 
@@ -633,14 +649,17 @@ fn main() -> Result<()> {
 
             println!("✓ Backup complete!");
             println!("   Files: {}", file_count);
-            println!("   Original size: {:.2} MB", total_bytes as f64 / 1_048_576.0);
+            println!(
+                "   Original size: {:.2} MB",
+                total_bytes as f64 / 1_048_576.0
+            );
             println!("   Backup size: {:.2} MB", output_size as f64 / 1_048_576.0);
             if compress {
                 println!("   Compression ratio: {:.1}%", compression_ratio);
             }
             println!("   Time: {:.2}s", elapsed.as_secs_f64());
             println!("   Output: {:?}", output_path);
-        }
+        },
 
         Commands::Restore { backup, dest } => {
             println!("📥 Restoring from backup...");
@@ -662,8 +681,9 @@ fn main() -> Result<()> {
             if dest.exists() {
                 println!("   ⚠️  Destination exists, files may be overwritten");
             } else {
-                fs::create_dir_all(&dest)
-                    .with_context(|| format!("Failed to create destination directory: {:?}", dest))?;
+                fs::create_dir_all(&dest).with_context(|| {
+                    format!("Failed to create destination directory: {:?}", dest)
+                })?;
             }
 
             let file = File::open(&backup)
@@ -734,7 +754,7 @@ fn main() -> Result<()> {
             println!("   Total size: {:.2} MB", total_bytes as f64 / 1_048_576.0);
             println!("   Time: {:.2}s", elapsed.as_secs_f64());
             println!("   Restored to: {:?}", dest);
-        }
+        },
 
         Commands::Optimize { dir, rebuild } => {
             let mut store = VecStore::open(&dir)?;
@@ -751,7 +771,7 @@ fn main() -> Result<()> {
 
             let elapsed = start.elapsed();
             println!("✓ Optimization complete in {:.2}s", elapsed.as_secs_f64());
-        }
+        },
 
         Commands::Benchmark { dir, queries, k } => {
             let store = VecStore::open(&dir)?;
@@ -793,7 +813,7 @@ fn main() -> Result<()> {
                 "   Throughput: {:.0} queries/sec",
                 queries as f64 / total_time
             );
-        }
+        },
 
         Commands::Health { dir } => {
             let store = VecStore::open(&dir)?;
@@ -808,7 +828,7 @@ fn main() -> Result<()> {
             if store.count() == 0 {
                 println!("⚠️  Warning: Store is empty");
             }
-        }
+        },
 
         Commands::Collection(cmd) => match cmd {
             CollectionCommands::List { dir } => {
@@ -820,7 +840,7 @@ fn main() -> Result<()> {
                 for name in collections {
                     println!("  - {}", name);
                 }
-            }
+            },
 
             CollectionCommands::Create {
                 dir,
@@ -831,14 +851,14 @@ fn main() -> Result<()> {
                 db.create_collection(&name)?;
 
                 println!("✓ Created collection '{}'", name);
-            }
+            },
 
             CollectionCommands::Drop { dir, name } => {
                 let mut db = VecDatabase::open(&dir)?;
                 db.delete_collection(&name)?;
 
                 println!("✓ Dropped collection '{}'", name);
-            }
+            },
 
             CollectionCommands::Info { dir, name } => {
                 let db = VecDatabase::open(&dir)?;
@@ -853,7 +873,7 @@ fn main() -> Result<()> {
                 } else {
                     println!("Collection '{}' not found", name);
                 }
-            }
+            },
         },
 
         Commands::Delete { dir, id, filter } => {
@@ -871,7 +891,7 @@ fn main() -> Result<()> {
                 eprintln!("Error: Must specify either --id or --filter");
                 std::process::exit(1);
             }
-        }
+        },
 
         Commands::Compact { dir } => {
             let mut store = VecStore::open(&dir)?;
@@ -890,7 +910,7 @@ fn main() -> Result<()> {
                 "  Removed: {} deleted vectors",
                 before.saturating_sub(after)
             );
-        }
+        },
     }
 
     Ok(())
diff --git a/src/bulk_migration.rs b/src/bulk_migration.rs
index 7116d12..f963a20 100644
--- a/src/bulk_migration.rs
+++ b/src/bulk_migration.rs
@@ -139,18 +139,19 @@ impl PineconeMigration {
 
         for (i, vector_data) in vectors.iter().enumerate().skip(start_offset) {
             if i % self.config.batch_size == 0
-                && let Some(ref callback) = self.progress_callback {
-                    callback(migrated, total);
-                }
+                && let Some(ref callback) = self.progress_callback
+            {
+                callback(migrated, total);
+            }
 
             match self.import_vector(vector_data, store) {
                 Ok(size) => {
                     migrated += 1;
                     bytes += size;
-                }
+                },
                 Err(_) => {
                     errors += 1;
-                }
+                },
             }
         }
 
@@ -238,9 +239,10 @@ impl QdrantMigration {
 
         for (i, line) in reader.lines().enumerate() {
             if let Some(offset) = self.config.resume_from
-                && i < offset {
-                    continue;
-                }
+                && i < offset
+            {
+                continue;
+            }
 
             let line = line.map_err(|e| anyhow::anyhow!("Read error: {}", e))?;
 
@@ -248,10 +250,10 @@ impl QdrantMigration {
                 Ok(size) => {
                     migrated += 1;
                     bytes += size;
-                }
+                },
                 Err(_) => {
                     errors += 1;
-                }
+                },
             }
         }
 
@@ -371,10 +373,10 @@ impl ChromaDBMigration {
                 Ok(_) => {
                     migrated += 1;
                     bytes += (id.len() + embedding.len() * 4 + 100) as u64;
-                }
+                },
                 Err(_) => {
                     errors += 1;
-                }
+                },
             }
         }
 
diff --git a/src/cache.rs b/src/cache.rs
index 3943206..c642c5e 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -13,8 +13,8 @@
 //! - Default capacity: 1000 entries
 //! - Configurable max size
 
-use std::collections::hash_map::DefaultHasher;
 use std::collections::HashMap;
+use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
@@ -77,12 +77,13 @@ impl<V: Clone> QueryCache<V> {
         if let Some(entry) = self.entries.get_mut(&hash) {
             // Check TTL if enabled
             if let Some(ttl) = self.ttl
-                && entry.inserted_at.elapsed() > ttl {
-                    // Entry expired, remove it
-                    self.entries.remove(&hash);
-                    self.misses += 1;
-                    return None;
-                }
+                && entry.inserted_at.elapsed() > ttl
+            {
+                // Entry expired, remove it
+                self.entries.remove(&hash);
+                self.misses += 1;
+                return None;
+            }
 
             // Update access time for LRU
             self.access_counter += 1;
@@ -244,19 +245,25 @@ impl<V: Clone> SharedQueryCache<V> {
 
     /// Get a cached value
     pub fn get(&self, key: &[f32]) -> Option<V> {
-        let Ok(mut guard) = self.inner.lock() else { return None; };
+        let Ok(mut guard) = self.inner.lock() else {
+            return None;
+        };
         guard.get(key)
     }
 
     /// Insert a value
     pub fn insert(&self, key: &[f32], value: V) {
-        let Ok(mut guard) = self.inner.lock() else { return; };
+        let Ok(mut guard) = self.inner.lock() else {
+            return;
+        };
         guard.insert(key, value);
     }
 
     /// Clear the cache
     pub fn clear(&self) {
-        let Ok(mut guard) = self.inner.lock() else { return; };
+        let Ok(mut guard) = self.inner.lock() else {
+            return;
+        };
         guard.clear();
     }
 
@@ -277,13 +284,17 @@ impl<V: Clone> SharedQueryCache<V> {
 
     /// Evict expired entries
     pub fn evict_expired(&self) -> usize {
-        let Ok(mut guard) = self.inner.lock() else { return 0; };
+        let Ok(mut guard) = self.inner.lock() else {
+            return 0;
+        };
         guard.evict_expired()
     }
 
     /// Get cache hit rate
     pub fn hit_rate(&self) -> f32 {
-        let Ok(guard) = self.inner.lock() else { return 0.0; };
+        let Ok(guard) = self.inner.lock() else {
+            return 0.0;
+        };
         guard.hit_rate()
     }
 
@@ -327,8 +338,7 @@ pub mod early_termination {
     impl Ord for HeapEntry {
         fn cmp(&self, other: &Self) -> Ordering {
             // Max-heap based on distance (peek gives largest distance)
-            self.distance
-                .total_cmp(&other.distance)
+            self.distance.total_cmp(&other.distance)
         }
     }
 
diff --git a/src/cdc.rs b/src/cdc.rs
index b1ede48..5724b3c 100644
--- a/src/cdc.rs
+++ b/src/cdc.rs
@@ -275,45 +275,51 @@ impl ChangeFilter {
                     if !ns.contains(event_ns) {
                         return false;
                     }
-                }
+                },
                 None => return false,
             }
         }
 
         // Check change type
         if let Some(ref cts) = self.change_types
-            && !cts.contains(&event.change_type) {
-                return false;
-            }
+            && !cts.contains(&event.change_type)
+        {
+            return false;
+        }
 
         // Check ID prefix
         if let Some(ref prefix) = self.id_prefix
-            && !event.vector_id.starts_with(prefix) {
-                return false;
-            }
+            && !event.vector_id.starts_with(prefix)
+        {
+            return false;
+        }
 
         // Check ID pattern (simple glob)
         if let Some(ref pattern) = self.id_pattern
-            && !glob_match(pattern, &event.vector_id) {
-                return false;
-            }
+            && !glob_match(pattern, &event.vector_id)
+        {
+            return false;
+        }
 
         // Check source
         if let Some(ref sources) = self.sources
-            && !sources.contains(&event.source) {
-                return false;
-            }
+            && !sources.contains(&event.source)
+        {
+            return false;
+        }
 
         // Check sequence range
         if let Some(from) = self.from_sequence
-            && event.sequence < from {
-                return false;
-            }
+            && event.sequence < from
+        {
+            return false;
+        }
 
         if let Some(to) = self.to_sequence
-            && event.sequence > to {
-                return false;
-            }
+            && event.sequence > to
+        {
+            return false;
+        }
 
         true
     }
@@ -333,7 +339,7 @@ fn glob_match_impl(pattern: &[char], text: &[char]) -> bool {
             // Try matching zero or more characters
             glob_match_impl(&pattern[1..], text)
                 || (!text.is_empty() && glob_match_impl(pattern, &text[1..]))
-        }
+        },
         (Some('?'), Some(_)) => glob_match_impl(&pattern[1..], &text[1..]),
         (Some(p), Some(t)) if p == t => glob_match_impl(&pattern[1..], &text[1..]),
         _ => false,
@@ -380,7 +386,7 @@ impl ChangeStream {
                     } else {
                         self.stats.filtered_out.fetch_add(1, Ordering::Relaxed);
                     }
-                }
+                },
                 Err(_) => return None,
             }
         }
@@ -406,7 +412,7 @@ impl ChangeStream {
                     } else {
                         self.stats.filtered_out.fetch_add(1, Ordering::Relaxed);
                     }
-                }
+                },
                 Err(mpsc::RecvTimeoutError::Timeout) => return None,
                 Err(mpsc::RecvTimeoutError::Disconnected) => return None,
             }
@@ -427,7 +433,7 @@ impl ChangeStream {
                     } else {
                         self.stats.filtered_out.fetch_add(1, Ordering::Relaxed);
                     }
-                }
+                },
                 Err(TryRecvError::Empty) => return None,
                 Err(TryRecvError::Disconnected) => return None,
             }
@@ -556,11 +562,11 @@ impl EventBroadcaster {
                 Ok(_) => {
                     self.inner.stats.published.fetch_add(1, Ordering::Relaxed);
                     true
-                }
+                },
                 Err(_) => {
                     // Subscriber dropped (disconnected)
                     false
-                }
+                },
             }
         });
 
@@ -653,7 +659,7 @@ impl AsyncChangeStream {
                     } else {
                         self.stats.filtered_out.fetch_add(1, Ordering::Relaxed);
                     }
-                }
+                },
                 None => return None,
             }
         }
@@ -753,7 +759,7 @@ impl AsyncEventBroadcaster {
             Ok(_) => {
                 self.inner.stats.published.fetch_add(1, Ordering::Relaxed);
                 true
-            }
+            },
             Err(_) => false,
         });
 
@@ -825,12 +831,16 @@ mod tests {
         assert!(!ChangeFilter::new().namespace("users").matches(&event));
 
         // Match by change type
-        assert!(ChangeFilter::new()
-            .change_type(ChangeType::Insert)
-            .matches(&event));
-        assert!(!ChangeFilter::new()
-            .change_type(ChangeType::Delete)
-            .matches(&event));
+        assert!(
+            ChangeFilter::new()
+                .change_type(ChangeType::Insert)
+                .matches(&event)
+        );
+        assert!(
+            !ChangeFilter::new()
+                .change_type(ChangeType::Delete)
+                .matches(&event)
+        );
 
         // Match by ID prefix
         assert!(ChangeFilter::new().id_prefix("products:").matches(&event));
@@ -891,8 +901,9 @@ mod tests {
         broadcaster.publish(
             VectorChangeEvent::insert("p1", vec![0.1]).with_namespace("products".to_string()),
         );
-        broadcaster
-            .publish(VectorChangeEvent::insert("u1", vec![0.2]).with_namespace("users".to_string()));
+        broadcaster.publish(
+            VectorChangeEvent::insert("u1", vec![0.2]).with_namespace("users".to_string()),
+        );
         broadcaster.publish(
             VectorChangeEvent::insert("p2", vec![0.3]).with_namespace("products".to_string()),
         );
diff --git a/src/change_streams.rs b/src/change_streams.rs
index e5a29a5..62992df 100644
--- a/src/change_streams.rs
+++ b/src/change_streams.rs
@@ -35,7 +35,10 @@
 //! ```
 
 use std::collections::{HashMap, VecDeque};
-use std::sync::{Arc, RwLock, atomic::{AtomicU64, AtomicBool, Ordering}};
+use std::sync::{
+    Arc, RwLock,
+    atomic::{AtomicBool, AtomicU64, Ordering},
+};
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use serde::{Deserialize, Serialize};
@@ -271,15 +274,17 @@ impl ChangeFilter {
     fn matches(&self, event: &ChangeEvent) -> bool {
         // Check operation
         if let Some(ops) = &self.operations
-            && !ops.contains(&event.operation) {
-                return false;
-            }
+            && !ops.contains(&event.operation)
+        {
+            return false;
+        }
 
         // Check document ID
         if let Some(ids) = &self.document_ids
-            && !ids.contains(&event.document_id) {
-                return false;
-            }
+            && !ids.contains(&event.document_id)
+        {
+            return false;
+        }
 
         // Check metadata
         if let Some(filter) = &self.metadata_filter {
@@ -322,12 +327,16 @@ impl Subscription {
 
     /// Get next event (non-blocking)
     pub fn try_next(&self) -> Result<Option<ChangeEvent>, VecStoreError> {
-        let mut events = self.events.write()
+        let mut events = self
+            .events
+            .write()
             .map_err(|_| VecStoreError::LockError("events lock poisoned".into()))?;
         let event = events.pop_front();
 
         if let Some(ref e) = event {
-            let mut token = self.last_token.write()
+            let mut token = self
+                .last_token
+                .write()
                 .map_err(|_| VecStoreError::LockError("last_token lock poisoned".into()))?;
             *token = Some(e.resume_token.clone());
         }
@@ -337,13 +346,17 @@ impl Subscription {
 
     /// Get batch of events
     pub fn try_batch(&self, max: usize) -> Result<Vec<ChangeEvent>, VecStoreError> {
-        let mut events = self.events.write()
+        let mut events = self
+            .events
+            .write()
             .map_err(|_| VecStoreError::LockError("events lock poisoned".into()))?;
         let count = max.min(events.len());
         let batch: Vec<ChangeEvent> = events.drain(..count).collect();
 
         if let Some(last) = batch.last() {
-            let mut token = self.last_token.write()
+            let mut token = self
+                .last_token
+                .write()
                 .map_err(|_| VecStoreError::LockError("last_token lock poisoned".into()))?;
             *token = Some(last.resume_token.clone());
         }
@@ -353,7 +366,9 @@ impl Subscription {
 
     /// Get last resume token
     pub fn resume_token(&self) -> Result<Option<ResumeToken>, VecStoreError> {
-        let token = self.last_token.read()
+        let token = self
+            .last_token
+            .read()
             .map_err(|_| VecStoreError::LockError("last_token lock poisoned".into()))?;
         Ok(token.clone())
     }
@@ -365,14 +380,18 @@ impl Subscription {
 
     /// Check if events are pending
     pub fn has_events(&self) -> Result<bool, VecStoreError> {
-        let events = self.events.read()
+        let events = self
+            .events
+            .read()
             .map_err(|_| VecStoreError::LockError("events lock poisoned".into()))?;
         Ok(!events.is_empty())
     }
 
     /// Get pending event count
     pub fn pending_count(&self) -> Result<usize, VecStoreError> {
-        let events = self.events.read()
+        let events = self
+            .events
+            .read()
             .map_err(|_| VecStoreError::LockError("events lock poisoned".into()))?;
         Ok(events.len())
     }
@@ -433,7 +452,9 @@ impl ChangeStream {
             last_token: Arc::new(RwLock::new(None)),
         });
 
-        let mut subs = self.subscriptions.write()
+        let mut subs = self
+            .subscriptions
+            .write()
             .map_err(|_| VecStoreError::LockError("subscriptions lock poisoned".into()))?;
         subs.insert(id, subscription.clone());
 
@@ -442,7 +463,9 @@ impl ChangeStream {
 
     /// Unwatch (close subscription)
     pub fn unwatch(&self, subscription_id: u64) -> Result<(), VecStoreError> {
-        let mut subs = self.subscriptions.write()
+        let mut subs = self
+            .subscriptions
+            .write()
             .map_err(|_| VecStoreError::LockError("subscriptions lock poisoned".into()))?;
         if let Some(sub) = subs.remove(&subscription_id) {
             sub.close();
@@ -451,7 +474,13 @@ impl ChangeStream {
     }
 
     /// Emit an event
-    pub fn emit(&self, operation: Operation, document_id: &str, before: Option<DocumentSnapshot>, after: Option<DocumentSnapshot>) -> Result<(), VecStoreError> {
+    pub fn emit(
+        &self,
+        operation: Operation,
+        document_id: &str,
+        before: Option<DocumentSnapshot>,
+        after: Option<DocumentSnapshot>,
+    ) -> Result<(), VecStoreError> {
         let event_id = self.event_counter.fetch_add(1, Ordering::Relaxed);
         let timestamp = unix_timestamp();
 
@@ -475,7 +504,9 @@ impl ChangeStream {
 
         // Add to log
         {
-            let mut log = self.event_log.write()
+            let mut log = self
+                .event_log
+                .write()
                 .map_err(|_| VecStoreError::LockError("event_log lock poisoned".into()))?;
             log.push_back(event.clone());
             while log.len() > self.max_log_size {
@@ -489,7 +520,12 @@ impl ChangeStream {
     }
 
     /// Emit insert event
-    pub fn emit_insert(&self, id: &str, vector: Vec<f32>, metadata: HashMap<String, serde_json::Value>) -> Result<(), VecStoreError> {
+    pub fn emit_insert(
+        &self,
+        id: &str,
+        vector: Vec<f32>,
+        metadata: HashMap<String, serde_json::Value>,
+    ) -> Result<(), VecStoreError> {
         let snapshot = DocumentSnapshot {
             id: id.to_string(),
             vector: Some(vector),
@@ -501,23 +537,35 @@ impl ChangeStream {
     }
 
     /// Emit update event
-    pub fn emit_update(&self, id: &str, before: Option<DocumentSnapshot>, after: DocumentSnapshot) -> Result<(), VecStoreError> {
+    pub fn emit_update(
+        &self,
+        id: &str,
+        before: Option<DocumentSnapshot>,
+        after: DocumentSnapshot,
+    ) -> Result<(), VecStoreError> {
         self.emit(Operation::Update, id, before, Some(after))
     }
 
     /// Emit delete event
-    pub fn emit_delete(&self, id: &str, before: Option<DocumentSnapshot>) -> Result<(), VecStoreError> {
+    pub fn emit_delete(
+        &self,
+        id: &str,
+        before: Option<DocumentSnapshot>,
+    ) -> Result<(), VecStoreError> {
         self.emit(Operation::Delete, id, before, None)
     }
 
     fn notify_subscriptions(&self, event: &ChangeEvent) -> Result<(), VecStoreError> {
-        let subs = self.subscriptions.read()
+        let subs = self
+            .subscriptions
+            .read()
             .map_err(|_| VecStoreError::LockError("subscriptions lock poisoned".into()))?;
 
         for sub in subs.values() {
             if sub.is_active() && sub.filter.matches(event) {
-                let mut events = sub.events.write()
-                    .map_err(|_| VecStoreError::LockError("subscription events lock poisoned".into()))?;
+                let mut events = sub.events.write().map_err(|_| {
+                    VecStoreError::LockError("subscription events lock poisoned".into())
+                })?;
 
                 // Apply backpressure
                 if events.len() < sub.filter.batch_size * 10 {
@@ -529,38 +577,49 @@ impl ChangeStream {
         Ok(())
     }
 
-    fn replay_from(&self, token: &ResumeToken, filter: &ChangeFilter) -> Result<VecDeque<ChangeEvent>, VecStoreError> {
-        let log = self.event_log.read()
+    fn replay_from(
+        &self,
+        token: &ResumeToken,
+        filter: &ChangeFilter,
+    ) -> Result<VecDeque<ChangeEvent>, VecStoreError> {
+        let log = self
+            .event_log
+            .read()
             .map_err(|_| VecStoreError::LockError("event_log lock poisoned".into()))?;
 
         // Find starting position
-        let start_id: u64 = token.token
+        let start_id: u64 = token
+            .token
             .split(':')
             .nth(1)
             .and_then(|s| s.parse().ok())
             .unwrap_or(0);
 
-        Ok(log.iter()
+        Ok(log
+            .iter()
             .filter(|e| e.id > start_id && filter.matches(e))
             .cloned()
             .collect())
     }
 
     fn replay_all(&self, filter: &ChangeFilter) -> Result<VecDeque<ChangeEvent>, VecStoreError> {
-        let log = self.event_log.read()
+        let log = self
+            .event_log
+            .read()
             .map_err(|_| VecStoreError::LockError("event_log lock poisoned".into()))?;
 
-        Ok(log.iter()
-            .filter(|e| filter.matches(e))
-            .cloned()
-            .collect())
+        Ok(log.iter().filter(|e| filter.matches(e)).cloned().collect())
     }
 
     /// Get statistics
     pub fn stats(&self) -> Result<ChangeStreamStats, VecStoreError> {
-        let subs = self.subscriptions.read()
+        let subs = self
+            .subscriptions
+            .read()
             .map_err(|_| VecStoreError::LockError("subscriptions lock poisoned".into()))?;
-        let log = self.event_log.read()
+        let log = self
+            .event_log
+            .read()
             .map_err(|_| VecStoreError::LockError("event_log lock poisoned".into()))?;
 
         Ok(ChangeStreamStats {
@@ -596,7 +655,9 @@ impl ChangeStreamManager {
 
     /// Get or create stream for collection
     pub fn stream(&self, collection: &str) -> Result<Arc<ChangeStream>, VecStoreError> {
-        let streams = self.streams.read()
+        let streams = self
+            .streams
+            .read()
             .map_err(|_| VecStoreError::LockError("streams lock poisoned".into()))?;
 
         if let Some(stream) = streams.get(collection) {
@@ -605,7 +666,9 @@ impl ChangeStreamManager {
 
         drop(streams);
 
-        let mut streams = self.streams.write()
+        let mut streams = self
+            .streams
+            .write()
             .map_err(|_| VecStoreError::LockError("streams lock poisoned".into()))?;
         Ok(streams
             .entry(collection.to_string())
@@ -615,20 +678,20 @@ impl ChangeStreamManager {
 
     /// Watch all collections
     pub fn watch_all(&self, filter: ChangeFilter) -> Result<Vec<Arc<Subscription>>, VecStoreError> {
-        let streams = self.streams.read()
+        let streams = self
+            .streams
+            .read()
             .map_err(|_| VecStoreError::LockError("streams lock poisoned".into()))?;
-        streams.values()
-            .map(|s| s.watch(filter.clone()))
-            .collect()
+        streams.values().map(|s| s.watch(filter.clone())).collect()
     }
 
     /// Get all statistics
     pub fn stats(&self) -> Result<Vec<ChangeStreamStats>, VecStoreError> {
-        let streams = self.streams.read()
+        let streams = self
+            .streams
+            .read()
             .map_err(|_| VecStoreError::LockError("streams lock poisoned".into()))?;
-        streams.values()
-            .map(|s| s.stats())
-            .collect()
+        streams.values().map(|s| s.stats()).collect()
     }
 }
 
@@ -657,8 +720,12 @@ mod tests {
         let sub = stream.watch(ChangeFilter::all()).unwrap();
 
         // Emit events
-        stream.emit_insert("doc1", vec![0.1, 0.2], HashMap::new()).unwrap();
-        stream.emit_insert("doc2", vec![0.3, 0.4], HashMap::new()).unwrap();
+        stream
+            .emit_insert("doc1", vec![0.1, 0.2], HashMap::new())
+            .unwrap();
+        stream
+            .emit_insert("doc2", vec![0.3, 0.4], HashMap::new())
+            .unwrap();
 
         // Check events
         let event1 = sub.try_next().unwrap().unwrap();
@@ -677,9 +744,13 @@ mod tests {
         let sub = stream.watch(ChangeFilter::inserts()).unwrap();
 
         // Emit mixed events
-        stream.emit_insert("doc1", vec![0.1], HashMap::new()).unwrap();
+        stream
+            .emit_insert("doc1", vec![0.1], HashMap::new())
+            .unwrap();
         stream.emit_delete("doc2", None).unwrap();
-        stream.emit_insert("doc3", vec![0.2], HashMap::new()).unwrap();
+        stream
+            .emit_insert("doc3", vec![0.2], HashMap::new())
+            .unwrap();
 
         // Should only get inserts
         let events = sub.try_batch(10).unwrap();
@@ -692,9 +763,15 @@ mod tests {
         let stream = ChangeStream::new("test");
 
         // Emit some events
-        stream.emit_insert("doc1", vec![0.1], HashMap::new()).unwrap();
-        stream.emit_insert("doc2", vec![0.2], HashMap::new()).unwrap();
-        stream.emit_insert("doc3", vec![0.3], HashMap::new()).unwrap();
+        stream
+            .emit_insert("doc1", vec![0.1], HashMap::new())
+            .unwrap();
+        stream
+            .emit_insert("doc2", vec![0.2], HashMap::new())
+            .unwrap();
+        stream
+            .emit_insert("doc3", vec![0.3], HashMap::new())
+            .unwrap();
 
         // First subscriber gets all events
         let sub1 = stream.watch(ChangeFilter::all()).unwrap();
@@ -704,7 +781,9 @@ mod tests {
         let token = events[1].resume_token.clone();
 
         // Second subscriber resumes after doc2
-        let sub2 = stream.watch(ChangeFilter::all().resume_after(token)).unwrap();
+        let sub2 = stream
+            .watch(ChangeFilter::all().resume_after(token))
+            .unwrap();
 
         // Should get doc3 only
         let events = sub2.try_batch(10).unwrap();
@@ -717,13 +796,26 @@ mod tests {
         let stream = ChangeStream::new("test");
 
         // Subscribe to specific documents
-        let sub = stream.watch(ChangeFilter::for_documents(vec!["doc1".to_string(), "doc3".to_string()])).unwrap();
+        let sub = stream
+            .watch(ChangeFilter::for_documents(vec![
+                "doc1".to_string(),
+                "doc3".to_string(),
+            ]))
+            .unwrap();
 
         // Emit events
-        stream.emit_insert("doc1", vec![0.1], HashMap::new()).unwrap();
-        stream.emit_insert("doc2", vec![0.2], HashMap::new()).unwrap();
-        stream.emit_insert("doc3", vec![0.3], HashMap::new()).unwrap();
-        stream.emit_insert("doc4", vec![0.4], HashMap::new()).unwrap();
+        stream
+            .emit_insert("doc1", vec![0.1], HashMap::new())
+            .unwrap();
+        stream
+            .emit_insert("doc2", vec![0.2], HashMap::new())
+            .unwrap();
+        stream
+            .emit_insert("doc3", vec![0.3], HashMap::new())
+            .unwrap();
+        stream
+            .emit_insert("doc4", vec![0.4], HashMap::new())
+            .unwrap();
 
         // Should only get doc1 and doc3
         let events = sub.try_batch(10).unwrap();
@@ -739,8 +831,12 @@ mod tests {
         let stream1 = manager.stream("collection1").unwrap();
         let stream2 = manager.stream("collection2").unwrap();
 
-        stream1.emit_insert("doc1", vec![0.1], HashMap::new()).unwrap();
-        stream2.emit_insert("doc2", vec![0.2], HashMap::new()).unwrap();
+        stream1
+            .emit_insert("doc1", vec![0.1], HashMap::new())
+            .unwrap();
+        stream2
+            .emit_insert("doc2", vec![0.2], HashMap::new())
+            .unwrap();
 
         let stats = manager.stats().unwrap();
         assert_eq!(stats.len(), 2);
@@ -765,7 +861,9 @@ mod tests {
             timestamp: unix_timestamp(),
         };
 
-        stream.emit_update("doc1", Some(before.clone()), after).unwrap();
+        stream
+            .emit_update("doc1", Some(before.clone()), after)
+            .unwrap();
 
         let event = sub.try_next().unwrap().unwrap();
         assert_eq!(event.operation, Operation::Update);
diff --git a/src/clustering.rs b/src/clustering.rs
index 951a912..ca287c7 100644
--- a/src/clustering.rs
+++ b/src/clustering.rs
@@ -603,14 +603,14 @@ impl HierarchicalClustering {
                     .iter()
                     .flat_map(|&i| cluster2.iter().map(move |&j| distances[i][j]))
                     .fold(f32::INFINITY, f32::min)
-            }
+            },
             LinkageMethod::Complete => {
                 // Maximum distance
                 cluster1
                     .iter()
                     .flat_map(|&i| cluster2.iter().map(move |&j| distances[i][j]))
                     .fold(0.0, f32::max)
-            }
+            },
             LinkageMethod::Average => {
                 // Average distance
                 let sum: f32 = cluster1
@@ -618,7 +618,7 @@ impl HierarchicalClustering {
                     .flat_map(|&i| cluster2.iter().map(move |&j| distances[i][j]))
                     .sum();
                 sum / (cluster1.len() * cluster2.len()) as f32
-            }
+            },
         }
     }
 
diff --git a/src/collection.rs b/src/collection.rs
index e5fce27..b94467e 100644
--- a/src/collection.rs
+++ b/src/collection.rs
@@ -137,8 +137,9 @@ impl VecDatabase {
 
         // Create namespace with quotas
         {
-            let manager = self.manager.read()
-                .map_err(|_| crate::error::VecStoreError::LockError("manager read lock poisoned".into()))?;
+            let manager = self.manager.read().map_err(|_| {
+                crate::error::VecStoreError::LockError("manager read lock poisoned".into())
+            })?;
             manager
                 .create_namespace(namespace_id.clone(), description, Some(config.quotas))
                 .map_err(|e| crate::error::VecStoreError::Other(e.to_string()))?;
@@ -168,8 +169,9 @@ impl VecDatabase {
     pub fn get_collection(&self, name: &str) -> Result<Option<Collection>> {
         let namespace_id: NamespaceId = name.to_string();
 
-        let manager = self.manager.read()
-            .map_err(|_| crate::error::VecStoreError::LockError("manager read lock poisoned".into()))?;
+        let manager = self.manager.read().map_err(|_| {
+            crate::error::VecStoreError::LockError("manager read lock poisoned".into())
+        })?;
         // Check if namespace exists
         match manager.get_namespace(&namespace_id) {
             Ok(_) => Ok(Some(Collection {
@@ -196,8 +198,9 @@ impl VecDatabase {
     /// # Ok::<(), anyhow::Error>(())
     /// ```
     pub fn list_collections(&self) -> Result<Vec<String>> {
-        let manager = self.manager.read()
-            .map_err(|_| crate::error::VecStoreError::LockError("manager read lock poisoned".into()))?;
+        let manager = self.manager.read().map_err(|_| {
+            crate::error::VecStoreError::LockError("manager read lock poisoned".into())
+        })?;
         let namespaces = manager.list_namespaces();
         Ok(namespaces.into_iter().map(|ns| ns.id).collect())
     }
@@ -215,8 +218,9 @@ impl VecDatabase {
     /// ```
     pub fn delete_collection(&mut self, name: &str) -> Result<()> {
         let namespace_id: NamespaceId = name.to_string();
-        let manager = self.manager.read()
-            .map_err(|_| crate::error::VecStoreError::LockError("manager read lock poisoned".into()))?;
+        let manager = self.manager.read().map_err(|_| {
+            crate::error::VecStoreError::LockError("manager read lock poisoned".into())
+        })?;
         manager
             .delete_namespace(&namespace_id)
             .map_err(|e| crate::error::VecStoreError::Other(e.to_string()))
@@ -315,8 +319,9 @@ impl Collection {
     ///
     /// Returns information about vector count, storage usage, etc.
     pub fn stats(&self) -> Result<NamespaceStats> {
-        let manager = self.manager.read()
-            .map_err(|_| crate::error::VecStoreError::LockError("manager read lock poisoned".into()))?;
+        let manager = self.manager.read().map_err(|_| {
+            crate::error::VecStoreError::LockError("manager read lock poisoned".into())
+        })?;
         manager
             .get_stats(&self.namespace_id)
             .map_err(|e| crate::error::VecStoreError::Other(e.to_string()))
@@ -324,8 +329,9 @@ impl Collection {
 
     /// Get namespace metadata (includes resource usage)
     pub fn namespace(&self) -> Result<Namespace> {
-        let manager = self.manager.read()
-            .map_err(|_| crate::error::VecStoreError::LockError("manager read lock poisoned".into()))?;
+        let manager = self.manager.read().map_err(|_| {
+            crate::error::VecStoreError::LockError("manager read lock poisoned".into())
+        })?;
         manager
             .get_namespace(&self.namespace_id)
             .map_err(|e| crate::error::VecStoreError::Other(e.to_string()))
@@ -350,8 +356,9 @@ impl Collection {
     /// # Ok::<(), anyhow::Error>(())
     /// ```
     pub fn upsert(&mut self, id: String, vector: Vec<f32>, metadata: Metadata) -> Result<()> {
-        let manager = self.manager.read()
-            .map_err(|_| crate::error::VecStoreError::LockError("manager read lock poisoned".into()))?;
+        let manager = self.manager.read().map_err(|_| {
+            crate::error::VecStoreError::LockError("manager read lock poisoned".into())
+        })?;
         manager
             .upsert(&self.namespace_id, id, vector, metadata)
             .map_err(|e| crate::error::VecStoreError::Other(e.to_string()))
@@ -379,8 +386,9 @@ impl Collection {
     /// # Ok::<(), anyhow::Error>(())
     /// ```
     pub fn query(&self, query: Query) -> Result<Vec<Neighbor>> {
-        let manager = self.manager.read()
-            .map_err(|_| crate::error::VecStoreError::LockError("manager read lock poisoned".into()))?;
+        let manager = self.manager.read().map_err(|_| {
+            crate::error::VecStoreError::LockError("manager read lock poisoned".into())
+        })?;
         manager
             .query(&self.namespace_id, query)
             .map_err(|e| crate::error::VecStoreError::Other(e.to_string()))
@@ -388,8 +396,9 @@ impl Collection {
 
     /// Delete a vector by ID
     pub fn delete(&mut self, id: &str) -> Result<()> {
-        let manager = self.manager.read()
-            .map_err(|_| crate::error::VecStoreError::LockError("manager read lock poisoned".into()))?;
+        let manager = self.manager.read().map_err(|_| {
+            crate::error::VecStoreError::LockError("manager read lock poisoned".into())
+        })?;
         manager
             .remove(&self.namespace_id, id)
             .map_err(|e| crate::error::VecStoreError::Other(e.to_string()))
diff --git a/src/columnar.rs b/src/columnar.rs
index 38e1904..7011bb3 100644
--- a/src/columnar.rs
+++ b/src/columnar.rs
@@ -38,15 +38,14 @@
 //! let stats = store.column_stats(0)?;
 //! ```
 
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
-use serde::{Deserialize, Serialize};
 
 use crate::error::VecStoreError;
 
 /// Compression type for columnar data
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[derive(Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub enum CompressionType {
     /// No compression
     #[default]
@@ -63,7 +62,6 @@ pub enum CompressionType {
     Dictionary,
 }
 
-
 /// Configuration for columnar storage
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ColumnarConfig {
@@ -170,27 +168,31 @@ impl ColumnarChunk {
     pub fn get_vector(&self, local_idx: usize) -> Result<Vec<f32>, VecStoreError> {
         if local_idx >= self.count {
             return Err(VecStoreError::NotFound(format!(
-                "Vector index {} out of range", local_idx
+                "Vector index {} out of range",
+                local_idx
             )));
         }
 
-        let vector: Vec<f32> = self.columns
-            .iter()
-            .map(|col| col[local_idx])
-            .collect();
+        let vector: Vec<f32> = self.columns.iter().map(|col| col[local_idx]).collect();
 
         Ok(vector)
     }
 
     /// Get specific dimensions for a vector
-    pub fn get_dimensions(&self, local_idx: usize, dims: &[usize]) -> Result<Vec<f32>, VecStoreError> {
+    pub fn get_dimensions(
+        &self,
+        local_idx: usize,
+        dims: &[usize],
+    ) -> Result<Vec<f32>, VecStoreError> {
         if local_idx >= self.count {
             return Err(VecStoreError::NotFound(format!(
-                "Vector index {} out of range", local_idx
+                "Vector index {} out of range",
+                local_idx
             )));
         }
 
-        let values: Vec<f32> = dims.iter()
+        let values: Vec<f32> = dims
+            .iter()
             .filter_map(|&d| {
                 if d < self.columns.len() {
                     Some(self.columns[d][local_idx])
@@ -205,7 +207,8 @@ impl ColumnarChunk {
 
     /// Compute statistics for all columns
     pub fn compute_stats(&mut self) {
-        let stats: Vec<ColumnStats> = self.columns
+        let stats: Vec<ColumnStats> = self
+            .columns
             .iter()
             .enumerate()
             .map(|(dim, col)| Self::compute_column_stats(dim, col))
@@ -233,12 +236,14 @@ impl ColumnarChunk {
         let sum: f64 = column.iter().map(|&x| x as f64).sum();
         let mean = sum / column.len() as f64;
 
-        let variance: f64 = column.iter()
+        let variance: f64 = column
+            .iter()
             .map(|&x| {
                 let diff = x as f64 - mean;
                 diff * diff
             })
-            .sum::<f64>() / column.len() as f64;
+            .sum::<f64>()
+            / column.len() as f64;
 
         let non_zero_count = column.iter().filter(|&&x| x != 0.0).count();
 
@@ -260,38 +265,39 @@ impl ColumnarChunk {
             CompressionType::None => {
                 self.compressed_columns = None;
                 Ok(())
-            }
+            },
             CompressionType::Delta => {
-                let compressed: Vec<Vec<u8>> = self.columns
+                let compressed: Vec<Vec<u8>> = self
+                    .columns
                     .iter()
                     .map(|col| Self::delta_encode(col))
                     .collect();
                 self.compressed_columns = Some(compressed);
                 Ok(())
-            }
+            },
             CompressionType::Rle => {
-                let compressed: Vec<Vec<u8>> = self.columns
+                let compressed: Vec<Vec<u8>> = self
+                    .columns
                     .iter()
                     .map(|col| Self::rle_encode(col))
                     .collect();
                 self.compressed_columns = Some(compressed);
                 Ok(())
-            }
+            },
             _ => {
                 // LZ4, Zstd would require external crates
                 // For now, store raw bytes
-                let compressed: Vec<Vec<u8>> = self.columns
+                let compressed: Vec<Vec<u8>> = self
+                    .columns
                     .iter()
                     .map(|col| {
-                        let bytes: Vec<u8> = col.iter()
-                            .flat_map(|&f| f.to_le_bytes())
-                            .collect();
+                        let bytes: Vec<u8> = col.iter().flat_map(|&f| f.to_le_bytes()).collect();
                         bytes
                     })
                     .collect();
                 self.compressed_columns = Some(compressed);
                 Ok(())
-            }
+            },
         }
     }
 
@@ -382,7 +388,11 @@ impl ColumnarStore {
     }
 
     /// Open or create a columnar store at path
-    pub fn open(path: impl AsRef<Path>, dimensions: usize, config: ColumnarConfig) -> Result<Self, VecStoreError> {
+    pub fn open(
+        path: impl AsRef<Path>,
+        dimensions: usize,
+        config: ColumnarConfig,
+    ) -> Result<Self, VecStoreError> {
         let path = path.as_ref().to_path_buf();
 
         if path.exists() {
@@ -398,8 +408,7 @@ impl ColumnarStore {
     fn load(path: &Path, config: ColumnarConfig) -> Result<Self, VecStoreError> {
         let meta_path = path.join("columnar_meta.json");
 
-        let file = std::fs::File::open(&meta_path)
-            .map_err(VecStoreError::Io)?;
+        let file = std::fs::File::open(&meta_path).map_err(VecStoreError::Io)?;
 
         let meta: ColumnarMeta = serde_json::from_reader(file)
             .map_err(|e| VecStoreError::Serialization(e.to_string()))?;
@@ -426,8 +435,7 @@ impl ColumnarStore {
     }
 
     fn load_chunk(&self, path: &Path) -> Result<ColumnarChunk, VecStoreError> {
-        let file = std::fs::File::open(path)
-            .map_err(VecStoreError::Io)?;
+        let file = std::fs::File::open(path).map_err(VecStoreError::Io)?;
 
         let chunk: ColumnarChunk = bincode::deserialize_from(file)
             .map_err(|e| VecStoreError::Serialization(e.to_string()))?;
@@ -487,7 +495,9 @@ impl ColumnarStore {
 
     /// Get a vector by ID
     pub fn get(&self, id: &str) -> Result<Vec<f32>, VecStoreError> {
-        let (chunk_idx, local_idx) = self.id_map.get(id)
+        let (chunk_idx, local_idx) = self
+            .id_map
+            .get(id)
             .ok_or_else(|| VecStoreError::NotFound(format!("Vector {} not found", id)))?;
 
         self.chunks[*chunk_idx].get_vector(*local_idx)
@@ -495,7 +505,9 @@ impl ColumnarStore {
 
     /// Read specific dimensions for a vector
     pub fn read_dimensions(&self, id: &str, dims: &[usize]) -> Result<Vec<f32>, VecStoreError> {
-        let (chunk_idx, local_idx) = self.id_map.get(id)
+        let (chunk_idx, local_idx) = self
+            .id_map
+            .get(id)
             .ok_or_else(|| VecStoreError::NotFound(format!("Vector {} not found", id)))?;
 
         self.chunks[*chunk_idx].get_dimensions(*local_idx, dims)
@@ -505,7 +517,8 @@ impl ColumnarStore {
     pub fn read_column(&self, dimension: usize) -> Result<Vec<f32>, VecStoreError> {
         if dimension >= self.dimensions {
             return Err(VecStoreError::InvalidInput(format!(
-                "Dimension {} out of range (max {})", dimension, self.dimensions
+                "Dimension {} out of range (max {})",
+                dimension, self.dimensions
             )));
         }
 
@@ -522,7 +535,8 @@ impl ColumnarStore {
     pub fn column_stats(&self, dimension: usize) -> Result<ColumnStats, VecStoreError> {
         if dimension >= self.dimensions {
             return Err(VecStoreError::InvalidInput(format!(
-                "Dimension {} out of range", dimension
+                "Dimension {} out of range",
+                dimension
             )));
         }
 
@@ -534,9 +548,8 @@ impl ColumnarStore {
     /// Get global statistics (across all dimensions)
     pub fn global_stats(&mut self) -> Result<&[ColumnStats], VecStoreError> {
         if self.global_stats.is_none() {
-            let stats: Result<Vec<ColumnStats>, _> = (0..self.dimensions)
-                .map(|d| self.column_stats(d))
-                .collect();
+            let stats: Result<Vec<ColumnStats>, _> =
+                (0..self.dimensions).map(|d| self.column_stats(d)).collect();
             self.global_stats = Some(stats?);
         }
 
@@ -545,7 +558,9 @@ impl ColumnarStore {
 
     /// Save to disk
     pub fn save(&self) -> Result<(), VecStoreError> {
-        let path = self.path.as_ref()
+        let path = self
+            .path
+            .as_ref()
             .ok_or_else(|| VecStoreError::InvalidInput("No path set for columnar store".into()))?;
 
         std::fs::create_dir_all(path).map_err(VecStoreError::Io)?;
@@ -559,16 +574,14 @@ impl ColumnarStore {
         };
 
         let meta_path = path.join("columnar_meta.json");
-        let file = std::fs::File::create(&meta_path)
-            .map_err(VecStoreError::Io)?;
+        let file = std::fs::File::create(&meta_path).map_err(VecStoreError::Io)?;
         serde_json::to_writer(file, &meta)
             .map_err(|e| VecStoreError::Serialization(e.to_string()))?;
 
         // Save chunks
         for (i, chunk) in self.chunks.iter().enumerate() {
             let chunk_path = path.join(format!("chunk_{}.bin", i));
-            let file = std::fs::File::create(&chunk_path)
-                .map_err(VecStoreError::Io)?;
+            let file = std::fs::File::create(&chunk_path).map_err(VecStoreError::Io)?;
             bincode::serialize_into(file, chunk)
                 .map_err(|e| VecStoreError::Serialization(e.to_string()))?;
         }
@@ -623,7 +636,8 @@ impl ColumnarStore {
                 }
                 new_chunks.push(current_chunk);
                 let new_idx = new_chunks.len();
-                current_chunk = ColumnarChunk::new(new_idx, new_count, self.dimensions, self.config.chunk_size);
+                current_chunk =
+                    ColumnarChunk::new(new_idx, new_count, self.dimensions, self.config.chunk_size);
             }
 
             let local_idx = current_chunk.count;
@@ -650,7 +664,10 @@ impl ColumnarStore {
     }
 
     /// Batch distance calculation (leverages columnar layout)
-    pub fn batch_euclidean_distance(&self, query: &[f32]) -> Result<Vec<(String, f32)>, VecStoreError> {
+    pub fn batch_euclidean_distance(
+        &self,
+        query: &[f32],
+    ) -> Result<Vec<(String, f32)>, VecStoreError> {
         if query.len() != self.dimensions {
             return Err(VecStoreError::DimensionMismatch {
                 expected: self.dimensions,
@@ -693,7 +710,8 @@ impl ColumnarStore {
     ) -> Result<Vec<String>, VecStoreError> {
         if dimension >= self.dimensions {
             return Err(VecStoreError::InvalidInput(format!(
-                "Dimension {} out of range", dimension
+                "Dimension {} out of range",
+                dimension
             )));
         }
 
@@ -730,7 +748,9 @@ impl ColumnarStore {
             if let Some(ref compressed) = chunk.compressed_columns {
                 size += compressed.iter().map(|c| c.len()).sum::<usize>();
             } else {
-                size += chunk.columns.iter()
+                size += chunk
+                    .columns
+                    .iter()
                     .map(|c| c.len() * size_of::<f32>())
                     .sum::<usize>();
             }
@@ -772,9 +792,10 @@ impl<'a> Iterator for ColumnarIterator<'a> {
 
     fn next(&mut self) -> Option<Self::Item> {
         if let Some((id, (chunk_idx, local_idx))) = self.id_iter.next()
-            && let Ok(vec) = self.store.chunks[*chunk_idx].get_vector(*local_idx) {
-                return Some((id.clone(), vec));
-            }
+            && let Ok(vec) = self.store.chunks[*chunk_idx].get_vector(*local_idx)
+        {
+            return Some((id.clone(), vec));
+        }
         None
     }
 }
diff --git a/src/compression.rs b/src/compression.rs
index 46afb78..63efb93 100644
--- a/src/compression.rs
+++ b/src/compression.rs
@@ -41,12 +41,11 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 
 /// Compression level
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[derive(Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum CompressionLevel {
     /// No compression (fastest)
     None,
@@ -62,7 +61,6 @@ pub enum CompressionLevel {
     Max,
 }
 
-
 /// Compression configuration
 #[derive(Debug, Clone)]
 pub struct CompressionConfig {
@@ -236,7 +234,7 @@ impl CompressionConfig {
                 {
                     Ok(data.to_vec())
                 }
-            }
+            },
             CompressionLevel::Balanced => {
                 #[cfg(feature = "compression")]
                 {
@@ -253,7 +251,7 @@ impl CompressionConfig {
                 {
                     Ok(data.to_vec())
                 }
-            }
+            },
             CompressionLevel::Max => {
                 #[cfg(feature = "compression")]
                 {
@@ -270,7 +268,7 @@ impl CompressionConfig {
                 {
                     Ok(data.to_vec())
                 }
-            }
+            },
         }
     }
 
@@ -289,17 +287,17 @@ impl CompressionConfig {
                     let decompressed = lz4_flex::decompress_size_prepended(&data[1..])
                         .map_err(|e| anyhow!("LZ4 decompression failed: {}", e))?;
                     Ok(decompressed)
-                }
+                },
                 Some(0x5A) => {
                     // ZSTD format
                     let decompressed = zstd::decode_all(std::io::Cursor::new(&data[1..]))
                         .map_err(|e| anyhow!("ZSTD decompression failed: {}", e))?;
                     Ok(decompressed)
-                }
+                },
                 _ => {
                     // Uncompressed data (no magic byte or unknown format)
                     Ok(data.to_vec())
-                }
+                },
             }
         }
         #[cfg(not(feature = "compression"))]
@@ -329,7 +327,7 @@ impl CompressionConfig {
                 }
 
                 Ok(output)
-            }
+            },
             16 => {
                 // 16-bit quantization
                 let min = values.iter().copied().fold(f32::INFINITY, f32::min);
@@ -346,7 +344,7 @@ impl CompressionConfig {
                 }
 
                 Ok(output)
-            }
+            },
             32 => {
                 // No compression, just convert to bytes
                 let mut output = Vec::with_capacity(values.len() * 4);
@@ -354,7 +352,7 @@ impl CompressionConfig {
                     output.extend_from_slice(&v.to_le_bytes());
                 }
                 Ok(output)
-            }
+            },
             _ => Err(anyhow!("Unsupported precision bits: {}", precision_bits)),
         }
     }
@@ -385,7 +383,7 @@ impl CompressionConfig {
                 }
 
                 Ok(values)
-            }
+            },
             16 => {
                 if data.len() < 8 {
                     return Err(anyhow!("Insufficient data for float decompression"));
@@ -406,7 +404,7 @@ impl CompressionConfig {
                 }
 
                 Ok(values)
-            }
+            },
             32 => {
                 let mut values = Vec::with_capacity(count);
                 for i in 0..count {
@@ -417,7 +415,7 @@ impl CompressionConfig {
                     values.push(f32::from_le_bytes(data[offset..offset + 4].try_into()?));
                 }
                 Ok(values)
-            }
+            },
             _ => Err(anyhow!("Unsupported precision bits: {}", precision_bits)),
         }
     }
diff --git a/src/cost_optimizer.rs b/src/cost_optimizer.rs
index b3d9f9c..eb1c8c3 100644
--- a/src/cost_optimizer.rs
+++ b/src/cost_optimizer.rs
@@ -2,8 +2,8 @@
 // Automatic scaling recommendations, resource right-sizing, and cost forecasting
 
 use std::collections::VecDeque;
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::RwLock;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, Instant};
 
 use serde::{Deserialize, Serialize};
@@ -179,13 +179,36 @@ pub enum EffortLevel {
 /// Optimization action
 #[derive(Debug, Clone, Serialize)]
 pub enum OptimizationAction {
-    ScaleDown { resource: String, current: f64, target: f64 },
-    ScaleUp { resource: String, current: f64, target: f64 },
-    EnableFeature { feature: String },
-    DisableFeature { feature: String },
-    ChangeConfig { key: String, current: String, target: String },
-    MigrateStorage { from_tier: String, to_tier: String, size_gb: f64 },
-    AdjustReplicas { current: u32, target: u32 },
+    ScaleDown {
+        resource: String,
+        current: f64,
+        target: f64,
+    },
+    ScaleUp {
+        resource: String,
+        current: f64,
+        target: f64,
+    },
+    EnableFeature {
+        feature: String,
+    },
+    DisableFeature {
+        feature: String,
+    },
+    ChangeConfig {
+        key: String,
+        current: String,
+        target: String,
+    },
+    MigrateStorage {
+        from_tier: String,
+        to_tier: String,
+        size_gb: f64,
+    },
+    AdjustReplicas {
+        current: u32,
+        target: u32,
+    },
 }
 
 /// Recommendation status
@@ -280,7 +303,9 @@ impl CostOptimizer {
             latency_ms: usage.latency_ms,
         };
 
-        let Ok(mut history) = self.resource_usage.write() else { return; };
+        let Ok(mut history) = self.resource_usage.write() else {
+            return;
+        };
         if history.samples.len() >= history.max_samples {
             history.samples.pop_front();
         }
@@ -288,8 +313,12 @@ impl CostOptimizer {
 
         // Calculate and record cost
         let cost = self.calculate_cost(&usage);
-        self.stats.total_cost.fetch_add((cost * 100.0) as u64, Ordering::Relaxed);
-        self.stats.total_queries.fetch_add(usage.queries, Ordering::Relaxed);
+        self.stats
+            .total_cost
+            .fetch_add((cost * 100.0) as u64, Ordering::Relaxed);
+        self.stats
+            .total_queries
+            .fetch_add(usage.queries, Ordering::Relaxed);
     }
 
     /// Calculate cost for resource usage
@@ -309,7 +338,9 @@ impl CostOptimizer {
 
     /// Analyze current costs and generate recommendations
     pub fn analyze(&self) -> Result<CostAnalysis> {
-        let history = self.resource_usage.read()
+        let history = self
+            .resource_usage
+            .read()
             .map_err(|_| VecStoreError::LockError("resource_usage lock poisoned".into()))?;
 
         if history.samples.is_empty() {
@@ -344,13 +375,14 @@ impl CostOptimizer {
 
         // Generate recommendations
         let recommendations = self.generate_recommendations(&avg_usage, &history.samples);
-        let potential_savings: f64 = recommendations.iter()
-            .map(|r| r.estimated_savings)
-            .sum();
+        let potential_savings: f64 = recommendations.iter().map(|r| r.estimated_savings).sum();
 
         // Store recommendations
-        *self.recommendations.write()
-            .map_err(|_| VecStoreError::LockError("recommendations lock poisoned".into()))? = recommendations.clone();
+        *self
+            .recommendations
+            .write()
+            .map_err(|_| VecStoreError::LockError("recommendations lock poisoned".into()))? =
+            recommendations.clone();
 
         Ok(CostAnalysis {
             current_costs,
@@ -397,7 +429,8 @@ impl CostOptimizer {
             return 0.0;
         }
 
-        let total_cost: f64 = samples.iter()
+        let total_cost: f64 = samples
+            .iter()
             .map(|s| {
                 let usage = ResourceUsage {
                     cpu_cores: s.cpu_cores,
@@ -430,13 +463,17 @@ impl CostOptimizer {
         let first_half: Vec<_> = samples.iter().take(half).collect();
         let second_half: Vec<_> = samples.iter().skip(half).collect();
 
-        let first_avg: f64 = first_half.iter()
+        let first_avg: f64 = first_half
+            .iter()
             .map(|s| self.calculate_cost(&ResourceUsage::from_sample(s)))
-            .sum::<f64>() / first_half.len() as f64;
+            .sum::<f64>()
+            / first_half.len() as f64;
 
-        let second_avg: f64 = second_half.iter()
+        let second_avg: f64 = second_half
+            .iter()
             .map(|s| self.calculate_cost(&ResourceUsage::from_sample(s)))
-            .sum::<f64>() / second_half.len() as f64;
+            .sum::<f64>()
+            / second_half.len() as f64;
 
         let change_percent = if first_avg > 0.0 {
             ((second_avg - first_avg) / first_avg) * 100.0
@@ -469,7 +506,8 @@ impl CostOptimizer {
         }
 
         let total_queries: u64 = samples.iter().map(|s| s.queries).sum();
-        let total_cost: f64 = samples.iter()
+        let total_cost: f64 = samples
+            .iter()
             .map(|s| self.calculate_cost(&ResourceUsage::from_sample(s)))
             .sum();
 
@@ -500,7 +538,8 @@ impl CostOptimizer {
         if cpu_utilization < 0.3 {
             let target_cores = (avg_usage.cpu_cores * 0.5).max(1.0);
             let savings = (avg_usage.cpu_cores - target_cores)
-                * self.config.pricing.cpu_per_core_hour * 720.0;
+                * self.config.pricing.cpu_per_core_hour
+                * 720.0;
 
             recommendations.push(CostRecommendation {
                 id: format!("cpu-rightsize-{}", now),
@@ -508,7 +547,9 @@ impl CostOptimizer {
                 title: "CPU Over-provisioned".to_string(),
                 description: format!(
                     "CPU utilization is only {:.0}%. Consider reducing cores from {:.1} to {:.1}.",
-                    cpu_utilization * 100.0, avg_usage.cpu_cores, target_cores
+                    cpu_utilization * 100.0,
+                    avg_usage.cpu_cores,
+                    target_cores
                 ),
                 estimated_savings: savings,
                 savings_percent: savings / self.project_monthly_cost(samples) * 100.0,
@@ -529,7 +570,8 @@ impl CostOptimizer {
         if memory_utilization < 0.4 {
             let target_memory = (avg_usage.memory_gb * 0.6).max(1.0);
             let savings = (avg_usage.memory_gb - target_memory)
-                * self.config.pricing.memory_per_gb_hour * 720.0;
+                * self.config.pricing.memory_per_gb_hour
+                * 720.0;
 
             recommendations.push(CostRecommendation {
                 id: format!("mem-rightsize-{}", now),
@@ -537,7 +579,9 @@ impl CostOptimizer {
                 title: "Memory Over-provisioned".to_string(),
                 description: format!(
                     "Memory utilization is only {:.0}%. Consider reducing from {:.1}GB to {:.1}GB.",
-                    memory_utilization * 100.0, avg_usage.memory_gb, target_memory
+                    memory_utilization * 100.0,
+                    avg_usage.memory_gb,
+                    target_memory
                 ),
                 estimated_savings: savings,
                 savings_percent: savings / self.project_monthly_cost(samples) * 100.0,
@@ -556,8 +600,10 @@ impl CostOptimizer {
         // Check storage tiering opportunity
         if avg_usage.storage_gb > 100.0 {
             let cold_data_ratio = 0.3; // Assume 30% could be cold
-            let cold_storage_savings = avg_usage.storage_gb * cold_data_ratio
-                * self.config.pricing.storage_per_gb_month * 0.7; // 70% savings on cold tier
+            let cold_storage_savings = avg_usage.storage_gb
+                * cold_data_ratio
+                * self.config.pricing.storage_per_gb_month
+                * 0.7; // 70% savings on cold tier
 
             recommendations.push(CostRecommendation {
                 id: format!("storage-tier-{}", now),
@@ -585,14 +631,18 @@ impl CostOptimizer {
         let estimated_cache_hit_rate = self.estimate_cache_hit_rate(samples);
         if estimated_cache_hit_rate < 0.7 {
             let potential_query_reduction = 0.2; // 20% of queries could be cached
-            let api_savings = avg_usage.queries as f64 * potential_query_reduction
-                * self.config.pricing.api_per_million / 1_000_000.0 * 720.0;
+            let api_savings = avg_usage.queries as f64
+                * potential_query_reduction
+                * self.config.pricing.api_per_million
+                / 1_000_000.0
+                * 720.0;
 
             recommendations.push(CostRecommendation {
                 id: format!("cache-improve-{}", now),
                 category: OptimizationCategory::CachingStrategy,
                 title: "Improve Cache Hit Rate".to_string(),
-                description: "Increase cache size or adjust caching strategy to improve hit rate.".to_string(),
+                description: "Increase cache size or adjust caching strategy to improve hit rate."
+                    .to_string(),
                 estimated_savings: api_savings,
                 savings_percent: api_savings / self.project_monthly_cost(samples) * 100.0,
                 risk: RiskLevel::Low,
@@ -608,11 +658,11 @@ impl CostOptimizer {
         }
 
         // Sort by estimated savings
-        recommendations.sort_by(|a, b| {
-            b.estimated_savings.total_cmp(&a.estimated_savings)
-        });
+        recommendations.sort_by(|a, b| b.estimated_savings.total_cmp(&a.estimated_savings));
 
-        self.stats.recommendations_generated.fetch_add(recommendations.len() as u64, Ordering::Relaxed);
+        self.stats
+            .recommendations_generated
+            .fetch_add(recommendations.len() as u64, Ordering::Relaxed);
 
         recommendations
     }
@@ -631,7 +681,8 @@ impl CostOptimizer {
             .unwrap_or(4.0);
 
         // Calculate average CPU cores in use across samples
-        let avg_cores_used: f64 = samples.iter().map(|s| s.cpu_cores).sum::<f64>() / samples.len() as f64;
+        let avg_cores_used: f64 =
+            samples.iter().map(|s| s.cpu_cores).sum::<f64>() / samples.len() as f64;
 
         // Convert to utilization percentage (0.0 - 1.0)
         (avg_cores_used / total_cores).clamp(0.0, 1.0)
@@ -649,7 +700,8 @@ impl CostOptimizer {
         let total_memory_gb = 16.0; // Assume 16GB system
 
         // Calculate average memory usage across samples
-        let avg_memory_used: f64 = samples.iter().map(|s| s.memory_gb).sum::<f64>() / samples.len() as f64;
+        let avg_memory_used: f64 =
+            samples.iter().map(|s| s.memory_gb).sum::<f64>() / samples.len() as f64;
 
         // Convert to utilization percentage (0.0 - 1.0)
         (avg_memory_used / total_memory_gb).clamp(0.0, 1.0)
@@ -664,7 +716,8 @@ impl CostOptimizer {
 
         // Estimate cache hit rate based on query patterns
         // Higher query rates with stable latency suggest good caching
-        let avg_latency: f64 = samples.iter().map(|s| s.latency_ms).sum::<f64>() / samples.len() as f64;
+        let avg_latency: f64 =
+            samples.iter().map(|s| s.latency_ms).sum::<f64>() / samples.len() as f64;
         let total_queries: u64 = samples.iter().map(|s| s.queries).sum();
 
         // Lower latency relative to query volume suggests cache hits
@@ -735,18 +788,26 @@ impl CostOptimizer {
 
     /// Apply a recommendation
     pub fn apply_recommendation(&self, recommendation_id: &str) -> Result<bool> {
-        let mut recommendations = self.recommendations.write()
+        let mut recommendations = self
+            .recommendations
+            .write()
             .map_err(|_| VecStoreError::LockError("recommendations lock poisoned".into()))?;
 
-        if let Some(rec) = recommendations.iter_mut().find(|r| r.id == recommendation_id) {
+        if let Some(rec) = recommendations
+            .iter_mut()
+            .find(|r| r.id == recommendation_id)
+        {
             if rec.status != RecommendationStatus::Pending {
                 return Ok(false);
             }
 
             rec.status = RecommendationStatus::Applied;
-            self.stats.recommendations_applied.fetch_add(1, Ordering::Relaxed);
-            *self.stats.savings_achieved.write()
-                .map_err(|_| VecStoreError::LockError("savings_achieved lock poisoned".into()))? += rec.estimated_savings;
+            self.stats
+                .recommendations_applied
+                .fetch_add(1, Ordering::Relaxed);
+            *self.stats.savings_achieved.write().map_err(|_| {
+                VecStoreError::LockError("savings_achieved lock poisoned".into())
+            })? += rec.estimated_savings;
 
             Ok(true)
         } else {
@@ -756,10 +817,15 @@ impl CostOptimizer {
 
     /// Dismiss a recommendation
     pub fn dismiss_recommendation(&self, recommendation_id: &str) -> Result<bool> {
-        let mut recommendations = self.recommendations.write()
+        let mut recommendations = self
+            .recommendations
+            .write()
             .map_err(|_| VecStoreError::LockError("recommendations lock poisoned".into()))?;
 
-        if let Some(rec) = recommendations.iter_mut().find(|r| r.id == recommendation_id) {
+        if let Some(rec) = recommendations
+            .iter_mut()
+            .find(|r| r.id == recommendation_id)
+        {
             rec.status = RecommendationStatus::Dismissed;
             Ok(true)
         } else {
@@ -769,7 +835,9 @@ impl CostOptimizer {
 
     /// Get pending recommendations
     pub fn get_recommendations(&self) -> Vec<CostRecommendation> {
-        let Ok(recommendations) = self.recommendations.read() else { return Vec::new(); };
+        let Ok(recommendations) = self.recommendations.read() else {
+            return Vec::new();
+        };
         recommendations
             .iter()
             .filter(|r| r.status == RecommendationStatus::Pending)
@@ -784,7 +852,10 @@ impl CostOptimizer {
                 total_cost: self.stats.total_cost.load(Ordering::Relaxed) as f64 / 100.0,
                 total_queries: self.stats.total_queries.load(Ordering::Relaxed),
                 cost_per_query: 0.0,
-                recommendations_generated: self.stats.recommendations_generated.load(Ordering::Relaxed),
+                recommendations_generated: self
+                    .stats
+                    .recommendations_generated
+                    .load(Ordering::Relaxed),
                 recommendations_applied: self.stats.recommendations_applied.load(Ordering::Relaxed),
                 savings_achieved: 0.0,
             };
@@ -795,7 +866,11 @@ impl CostOptimizer {
             cost_per_query: {
                 let cost = self.stats.total_cost.load(Ordering::Relaxed) as f64 / 100.0;
                 let queries = self.stats.total_queries.load(Ordering::Relaxed);
-                if queries > 0 { cost / queries as f64 } else { 0.0 }
+                if queries > 0 {
+                    cost / queries as f64
+                } else {
+                    0.0
+                }
             },
             recommendations_generated: self.stats.recommendations_generated.load(Ordering::Relaxed),
             recommendations_applied: self.stats.recommendations_applied.load(Ordering::Relaxed),
@@ -812,7 +887,9 @@ impl CostOptimizer {
             pessimistic_forecast: 0.0,
             with_recommendations: 0.0,
         };
-        let Ok(history) = self.resource_usage.read() else { return default_forecast; };
+        let Ok(history) = self.resource_usage.read() else {
+            return default_forecast;
+        };
         let monthly_cost = self.project_monthly_cost(&history.samples);
         let daily_cost = monthly_cost / 30.0;
 
@@ -975,15 +1052,16 @@ impl CostAwareAutoScaler {
 
         // Check cooldown
         if let Some(last_action) = state.last_scale_action
-            && last_action.elapsed() < self.config.cooldown_period {
-                return ScalingDecision {
-                    action: ScaleAction::NoChange,
-                    current_replicas: state.replicas,
-                    target_replicas: state.replicas,
-                    reason: "In cooldown period".to_string(),
-                    cost_impact: 0.0,
-                };
-            }
+            && last_action.elapsed() < self.config.cooldown_period
+        {
+            return ScalingDecision {
+                action: ScaleAction::NoChange,
+                current_replicas: state.replicas,
+                target_replicas: state.replicas,
+                reason: "In cooldown period".to_string(),
+                cost_impact: 0.0,
+            };
+        }
 
         let current_replicas = state.replicas;
         drop(state);
@@ -1025,7 +1103,8 @@ impl CostAwareAutoScaler {
                 target_replicas: target,
                 reason: format!(
                     "Low utilization ({:.0}%) and high cost per query (${:.6})",
-                    utilization_per_replica * 100.0, current_cost_per_query
+                    utilization_per_replica * 100.0,
+                    current_cost_per_query
                 ),
                 cost_impact: -cost_savings,
             };
@@ -1047,7 +1126,8 @@ impl CostAwareAutoScaler {
         let memory_per_replica = 8.0;
 
         (cpu_per_replica * pricing.cpu_per_core_hour
-            + memory_per_replica * pricing.memory_per_gb_hour) * 720.0
+            + memory_per_replica * pricing.memory_per_gb_hour)
+            * 720.0
     }
 
     /// Apply scaling decision
@@ -1056,7 +1136,9 @@ impl CostAwareAutoScaler {
             return false;
         }
 
-        let Ok(mut state) = self.current_scale.write() else { return false; };
+        let Ok(mut state) = self.current_scale.write() else {
+            return false;
+        };
         state.replicas = decision.target_replicas;
         state.last_scale_action = Some(Instant::now());
 
diff --git a/src/data_lineage.rs b/src/data_lineage.rs
index fabf449..cf70d7c 100644
--- a/src/data_lineage.rs
+++ b/src/data_lineage.rs
@@ -129,7 +129,10 @@ pub enum DerivationOperation {
     /// Normalization
     Normalization { method: String },
     /// Custom transformation
-    Custom { name: String, parameters: HashMap<String, String> },
+    Custom {
+        name: String,
+        parameters: HashMap<String, String>,
+    },
 }
 
 /// Transformation applied to a vector
@@ -313,14 +316,19 @@ impl LineageTracker {
         // Handle derived sources
         if let VectorSource::Derived { ref parent_ids, .. } = source {
             let Ok(mut forward) = self.forward_deps.write() else {
-                return Err(VecStoreError::Internal("Failed to acquire forward_deps write lock".to_string()));
+                return Err(VecStoreError::Internal(
+                    "Failed to acquire forward_deps write lock".to_string(),
+                ));
             };
             let Ok(mut backward) = self.backward_deps.write() else {
-                return Err(VecStoreError::Internal("Failed to acquire backward_deps write lock".to_string()));
+                return Err(VecStoreError::Internal(
+                    "Failed to acquire backward_deps write lock".to_string(),
+                ));
             };
 
             for parent_id in parent_ids {
-                forward.entry(parent_id.clone())
+                forward
+                    .entry(parent_id.clone())
                     .or_insert_with(HashSet::new)
                     .insert(vector_id.clone());
             }
@@ -329,7 +337,9 @@ impl LineageTracker {
         }
 
         let Ok(mut records) = self.records.write() else {
-            return Err(VecStoreError::Internal("Failed to acquire records write lock".to_string()));
+            return Err(VecStoreError::Internal(
+                "Failed to acquire records write lock".to_string(),
+            ));
         };
         records.insert(vector_id, record);
 
@@ -350,7 +360,9 @@ impl LineageTracker {
         // Update input records
         {
             let Ok(mut records) = self.records.write() else {
-                return Err(VecStoreError::Internal("Failed to acquire records write lock".to_string()));
+                return Err(VecStoreError::Internal(
+                    "Failed to acquire records write lock".to_string(),
+                ));
             };
             for input_id in &transformation.inputs {
                 if let Some(record) = records.get_mut(input_id) {
@@ -363,10 +375,14 @@ impl LineageTracker {
         // Track dependencies
         {
             let Ok(mut forward) = self.forward_deps.write() else {
-                return Err(VecStoreError::Internal("Failed to acquire forward_deps write lock".to_string()));
+                return Err(VecStoreError::Internal(
+                    "Failed to acquire forward_deps write lock".to_string(),
+                ));
             };
             let Ok(mut backward) = self.backward_deps.write() else {
-                return Err(VecStoreError::Internal("Failed to acquire backward_deps write lock".to_string()));
+                return Err(VecStoreError::Internal(
+                    "Failed to acquire backward_deps write lock".to_string(),
+                ));
             };
 
             for output_id in &transformation.outputs {
@@ -384,12 +400,16 @@ impl LineageTracker {
         }
 
         let Ok(mut transformations) = self.transformations.write() else {
-            return Err(VecStoreError::Internal("Failed to acquire transformations write lock".to_string()));
+            return Err(VecStoreError::Internal(
+                "Failed to acquire transformations write lock".to_string(),
+            ));
         };
         transformations.insert(transform_id, transformation);
 
         use std::sync::atomic::Ordering;
-        self.metrics.transformations_recorded.fetch_add(1, Ordering::Relaxed);
+        self.metrics
+            .transformations_recorded
+            .fetch_add(1, Ordering::Relaxed);
 
         Ok(())
     }
@@ -415,7 +435,9 @@ impl LineageTracker {
         };
 
         let Ok(mut log) = self.access_log.write() else {
-            return Err(VecStoreError::Internal("Failed to acquire access_log write lock".to_string()));
+            return Err(VecStoreError::Internal(
+                "Failed to acquire access_log write lock".to_string(),
+            ));
         };
         log.push_back(record);
 
@@ -542,7 +564,8 @@ impl LineageTracker {
         let Ok(records) = self.records.read() else {
             return Vec::new();
         };
-        records.iter()
+        records
+            .iter()
             .filter(|(_, record)| {
                 let record_type = match &record.source {
                     VectorSource::DirectInsert { .. } => "direct",
@@ -565,7 +588,8 @@ impl LineageTracker {
         let Ok(records) = self.records.read() else {
             return Vec::new();
         };
-        records.iter()
+        records
+            .iter()
             .filter(|(_, record)| record.tags.contains(tag))
             .map(|(id, _)| id.clone())
             .collect()
@@ -574,14 +598,19 @@ impl LineageTracker {
     /// Add tag to vector
     pub fn add_tag(&self, vector_id: &VectorId, tag: &str) -> Result<()> {
         let Ok(mut records) = self.records.write() else {
-            return Err(VecStoreError::Internal("Failed to acquire records write lock".to_string()));
+            return Err(VecStoreError::Internal(
+                "Failed to acquire records write lock".to_string(),
+            ));
         };
         if let Some(record) = records.get_mut(vector_id) {
             record.tags.insert(tag.to_string());
             record.modified_at = current_timestamp();
             Ok(())
         } else {
-            Err(VecStoreError::NotFound(format!("Vector {:?} not found", vector_id)))
+            Err(VecStoreError::NotFound(format!(
+                "Vector {:?} not found",
+                vector_id
+            )))
         }
     }
 
@@ -595,7 +624,9 @@ impl LineageTracker {
         };
 
         if let Some(record) = records.get(vector_id) {
-            record.transformations.iter()
+            record
+                .transformations
+                .iter()
                 .filter_map(|id| transformations.get(id).cloned())
                 .collect()
         } else {
@@ -689,7 +720,10 @@ impl LineageTracker {
                     total_transformations: 0,
                     records_by_source: HashMap::new(),
                     records_created: self.metrics.records_created.load(Ordering::Relaxed),
-                    transformations_recorded: self.metrics.transformations_recorded.load(Ordering::Relaxed),
+                    transformations_recorded: self
+                        .metrics
+                        .transformations_recorded
+                        .load(Ordering::Relaxed),
                     lineage_queries: self.metrics.lineage_queries.load(Ordering::Relaxed),
                     impact_analyses: self.metrics.impact_analyses.load(Ordering::Relaxed),
                 };
@@ -700,7 +734,10 @@ impl LineageTracker {
                     total_transformations: 0,
                     records_by_source: HashMap::new(),
                     records_created: self.metrics.records_created.load(Ordering::Relaxed),
-                    transformations_recorded: self.metrics.transformations_recorded.load(Ordering::Relaxed),
+                    transformations_recorded: self
+                        .metrics
+                        .transformations_recorded
+                        .load(Ordering::Relaxed),
                     lineage_queries: self.metrics.lineage_queries.load(Ordering::Relaxed),
                     impact_analyses: self.metrics.impact_analyses.load(Ordering::Relaxed),
                 };
@@ -729,7 +766,10 @@ impl LineageTracker {
             total_transformations,
             records_by_source: source_counts,
             records_created: self.metrics.records_created.load(Ordering::Relaxed),
-            transformations_recorded: self.metrics.transformations_recorded.load(Ordering::Relaxed),
+            transformations_recorded: self
+                .metrics
+                .transformations_recorded
+                .load(Ordering::Relaxed),
             lineage_queries: self.metrics.lineage_queries.load(Ordering::Relaxed),
             impact_analyses: self.metrics.impact_analyses.load(Ordering::Relaxed),
         }
@@ -737,7 +777,8 @@ impl LineageTracker {
 
     /// Cleanup old records based on retention policy
     pub fn cleanup(&self) -> usize {
-        let cutoff = current_timestamp() - (self.config.retention_days as u64 * 24 * 60 * 60 * 1000);
+        let cutoff =
+            current_timestamp() - (self.config.retention_days as u64 * 24 * 60 * 60 * 1000);
 
         let Ok(mut records) = self.records.write() else {
             return 0;
@@ -807,7 +848,8 @@ fn compute_quality_metrics(vector: &[f32]) -> QualityMetrics {
     }
 
     let n = vector.len() as f32;
-    let entropy: f32 = value_counts.values()
+    let entropy: f32 = value_counts
+        .values()
         .map(|&count| {
             let p = count as f32 / n;
             if p > 0.0 { -p * p.log2() } else { 0.0 }
@@ -838,13 +880,9 @@ mod tests {
             api_version: "v1".to_string(),
         };
 
-        tracker.record_creation(
-            vector_id.clone(),
-            source,
-            128,
-            None,
-            Some(&vec![0.1; 128]),
-        ).unwrap();
+        tracker
+            .record_creation(vector_id.clone(), source, 128, None, Some(&vec![0.1; 128]))
+            .unwrap();
 
         let lineage = tracker.get_lineage(&vector_id).unwrap();
         assert_eq!(lineage.original_dimensions, 128);
@@ -858,32 +896,48 @@ mod tests {
         let parent1 = VectorId::new("test", "parent1");
         let parent2 = VectorId::new("test", "parent2");
 
-        tracker.record_creation(
-            parent1.clone(),
-            VectorSource::DirectInsert {
-                user: None, client_ip: None, api_version: "v1".to_string(),
-            },
-            128, None, None,
-        ).unwrap();
-
-        tracker.record_creation(
-            parent2.clone(),
-            VectorSource::DirectInsert {
-                user: None, client_ip: None, api_version: "v1".to_string(),
-            },
-            128, None, None,
-        ).unwrap();
+        tracker
+            .record_creation(
+                parent1.clone(),
+                VectorSource::DirectInsert {
+                    user: None,
+                    client_ip: None,
+                    api_version: "v1".to_string(),
+                },
+                128,
+                None,
+                None,
+            )
+            .unwrap();
+
+        tracker
+            .record_creation(
+                parent2.clone(),
+                VectorSource::DirectInsert {
+                    user: None,
+                    client_ip: None,
+                    api_version: "v1".to_string(),
+                },
+                128,
+                None,
+                None,
+            )
+            .unwrap();
 
         // Create derived vector
         let child = VectorId::new("test", "child");
-        tracker.record_creation(
-            child.clone(),
-            VectorSource::Derived {
-                parent_ids: vec![parent1.clone(), parent2.clone()],
-                operation: DerivationOperation::Average,
-            },
-            128, None, None,
-        ).unwrap();
+        tracker
+            .record_creation(
+                child.clone(),
+                VectorSource::Derived {
+                    parent_ids: vec![parent1.clone(), parent2.clone()],
+                    operation: DerivationOperation::Average,
+                },
+                128,
+                None,
+                None,
+            )
+            .unwrap();
 
         // Check ancestry
         let ancestors = tracker.get_ancestry(&child);
@@ -902,34 +956,52 @@ mod tests {
         let tracker = LineageTracker::new(LineageConfig::default());
 
         let root = VectorId::new("test", "root");
-        tracker.record_creation(
-            root.clone(),
-            VectorSource::DirectInsert {
-                user: None, client_ip: None, api_version: "v1".to_string(),
-            },
-            128, None, None,
-        ).unwrap();
+        tracker
+            .record_creation(
+                root.clone(),
+                VectorSource::DirectInsert {
+                    user: None,
+                    client_ip: None,
+                    api_version: "v1".to_string(),
+                },
+                128,
+                None,
+                None,
+            )
+            .unwrap();
 
         // Create chain of derived vectors
         let level1 = VectorId::new("test", "level1");
-        tracker.record_creation(
-            level1.clone(),
-            VectorSource::Derived {
-                parent_ids: vec![root.clone()],
-                operation: DerivationOperation::Normalization { method: "l2".to_string() },
-            },
-            128, None, None,
-        ).unwrap();
+        tracker
+            .record_creation(
+                level1.clone(),
+                VectorSource::Derived {
+                    parent_ids: vec![root.clone()],
+                    operation: DerivationOperation::Normalization {
+                        method: "l2".to_string(),
+                    },
+                },
+                128,
+                None,
+                None,
+            )
+            .unwrap();
 
         let level2 = VectorId::new("test", "level2");
-        tracker.record_creation(
-            level2.clone(),
-            VectorSource::Derived {
-                parent_ids: vec![level1.clone()],
-                operation: DerivationOperation::Quantization { method: "pq".to_string() },
-            },
-            128, None, None,
-        ).unwrap();
+        tracker
+            .record_creation(
+                level2.clone(),
+                VectorSource::Derived {
+                    parent_ids: vec![level1.clone()],
+                    operation: DerivationOperation::Quantization {
+                        method: "pq".to_string(),
+                    },
+                },
+                128,
+                None,
+                None,
+            )
+            .unwrap();
 
         let report = tracker.impact_analysis(&root);
         assert_eq!(report.total_affected, 2);
@@ -942,22 +1014,32 @@ mod tests {
         let parent = VectorId::new("test", "parent");
         let child = VectorId::new("test", "child");
 
-        tracker.record_creation(
-            parent.clone(),
-            VectorSource::DirectInsert {
-                user: None, client_ip: None, api_version: "v1".to_string(),
-            },
-            128, None, None,
-        ).unwrap();
-
-        tracker.record_creation(
-            child.clone(),
-            VectorSource::Derived {
-                parent_ids: vec![parent.clone()],
-                operation: DerivationOperation::Average,
-            },
-            128, None, None,
-        ).unwrap();
+        tracker
+            .record_creation(
+                parent.clone(),
+                VectorSource::DirectInsert {
+                    user: None,
+                    client_ip: None,
+                    api_version: "v1".to_string(),
+                },
+                128,
+                None,
+                None,
+            )
+            .unwrap();
+
+        tracker
+            .record_creation(
+                child.clone(),
+                VectorSource::Derived {
+                    parent_ids: vec![parent.clone()],
+                    operation: DerivationOperation::Average,
+                },
+                128,
+                None,
+                None,
+            )
+            .unwrap();
 
         let dot = tracker.export_graph(&parent, 2);
         assert!(dot.contains("digraph"));
diff --git a/src/debugger.rs b/src/debugger.rs
index 6d31c10..35d6a56 100644
--- a/src/debugger.rs
+++ b/src/debugger.rs
@@ -30,7 +30,7 @@
 //! let anomalies = debugger.detect_anomalies(&embeddings)?;
 //! ```
 
-use anyhow::{Result};
+use anyhow::Result;
 use serde::{Deserialize, Serialize};
 
 // ============================================================================
@@ -299,7 +299,8 @@ impl EmbeddingDebugger {
                     distribution.norm
                 ),
                 affected_dimensions: None,
-                suggestion: "The embedding may be collapsed. Try different input or model.".to_string(),
+                suggestion: "The embedding may be collapsed. Try different input or model."
+                    .to_string(),
             });
             quality_score -= 0.2;
         } else if distribution.norm > self.config.high_norm_threshold {
@@ -323,7 +324,8 @@ impl EmbeddingDebugger {
                 category: IssueCategory::Collapsed,
                 message: "Embedding appears to be collapsed (near-constant values)".to_string(),
                 affected_dimensions: None,
-                suggestion: "The model may be producing degenerate embeddings. Check model output.".to_string(),
+                suggestion: "The model may be producing degenerate embeddings. Check model output."
+                    .to_string(),
             });
             quality_score -= 0.4;
         }
@@ -347,7 +349,8 @@ impl EmbeddingDebugger {
         let dimension_stats = self.analyze_dimensions(embedding);
 
         // Check for low variance dimensions
-        let low_var_ratio = dimension_stats.zero_variance_dims as f32 / dimension_stats.total as f32;
+        let low_var_ratio =
+            dimension_stats.zero_variance_dims as f32 / dimension_stats.total as f32;
         if low_var_ratio > 0.5 {
             issues.push(QualityIssue {
                 severity: IssueSeverity::Warning,
@@ -357,7 +360,9 @@ impl EmbeddingDebugger {
                     low_var_ratio * 100.0
                 ),
                 affected_dimensions: None,
-                suggestion: "Many dimensions are not being used. Consider dimensionality reduction.".to_string(),
+                suggestion:
+                    "Many dimensions are not being used. Consider dimensionality reduction."
+                        .to_string(),
             });
             quality_score -= 0.1;
         }
@@ -367,7 +372,10 @@ impl EmbeddingDebugger {
             issues.push(QualityIssue {
                 severity: IssueSeverity::Info,
                 category: IssueCategory::Skewed,
-                message: format!("Distribution is highly skewed ({:.2})", distribution.skewness),
+                message: format!(
+                    "Distribution is highly skewed ({:.2})",
+                    distribution.skewness
+                ),
                 affected_dimensions: None,
                 suggestion: "This may be normal for your data type.".to_string(),
             });
@@ -545,7 +553,8 @@ impl EmbeddingDebugger {
             .map(|(i, &v)| (i, (v - mean).abs()))
             .collect();
         variance_indexed.sort_by(|a, b| b.1.total_cmp(&a.1));
-        let high_variance_dims: Vec<(usize, f32)> = variance_indexed.iter().take(10).cloned().collect();
+        let high_variance_dims: Vec<(usize, f32)> =
+            variance_indexed.iter().take(10).cloned().collect();
 
         DimensionStats {
             total,
@@ -571,11 +580,13 @@ impl EmbeddingDebugger {
         let has_high_norm = issues.iter().any(|i| i.category == IssueCategory::HighNorm);
 
         if has_critical {
-            recommendations.push("Critical issues detected. Review your embedding pipeline.".to_string());
+            recommendations
+                .push("Critical issues detected. Review your embedding pipeline.".to_string());
         }
 
         if has_low_norm {
-            recommendations.push("Consider checking if input text is empty or very short.".to_string());
+            recommendations
+                .push("Consider checking if input text is empty or very short.".to_string());
         }
 
         if has_high_norm {
@@ -583,7 +594,8 @@ impl EmbeddingDebugger {
         }
 
         if distribution.sparsity > 0.5 {
-            recommendations.push("High sparsity detected. Consider using sparse vector storage.".to_string());
+            recommendations
+                .push("High sparsity detected. Consider using sparse vector storage.".to_string());
         }
 
         if issues.is_empty() {
@@ -699,9 +711,10 @@ impl EmbeddingDebugger {
 
     /// Check for drift compared to baseline
     pub fn check_drift(&mut self, embeddings: &[Vec<f32>]) -> Result<DriftReport> {
-        let baseline = self.baseline.as_ref().ok_or_else(|| {
-            anyhow::anyhow!("No baseline set. Call set_baseline first.")
-        })?;
+        let baseline = self
+            .baseline
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("No baseline set. Call set_baseline first."))?;
 
         if embeddings.is_empty() {
             return Ok(DriftReport {
@@ -724,8 +737,8 @@ impl EmbeddingDebugger {
         let current_mean_norm = norms.iter().sum::<f32>() / n;
 
         // Norm drift
-        let norm_drift = (current_mean_norm - baseline.mean_norm).abs()
-            / (baseline.std_norm + 1e-10);
+        let norm_drift =
+            (current_mean_norm - baseline.mean_norm).abs() / (baseline.std_norm + 1e-10);
 
         // Per-dimension drift
         let mut current_mean_per_dim = vec![0.0f32; baseline.dimension];
@@ -958,10 +971,12 @@ mod tests {
         let report = debugger.analyze(&embedding).unwrap();
 
         assert!(report.quality_score < 0.7);
-        assert!(report
-            .issues
-            .iter()
-            .any(|i| i.category == IssueCategory::LowEntropy));
+        assert!(
+            report
+                .issues
+                .iter()
+                .any(|i| i.category == IssueCategory::LowEntropy)
+        );
     }
 
     #[test]
@@ -973,10 +988,12 @@ mod tests {
 
         let report = debugger.analyze(&embedding).unwrap();
 
-        assert!(report
-            .issues
-            .iter()
-            .any(|i| i.category == IssueCategory::InvalidValues));
+        assert!(
+            report
+                .issues
+                .iter()
+                .any(|i| i.category == IssueCategory::InvalidValues)
+        );
         assert!(report.quality_score < 0.6);
     }
 
@@ -985,9 +1002,8 @@ mod tests {
         let debugger = EmbeddingDebugger::new(DebugConfig::default());
 
         // Generate normal embeddings
-        let mut embeddings: Vec<Vec<f32>> = (0..50)
-            .map(|_| generate_random_embedding(128))
-            .collect();
+        let mut embeddings: Vec<Vec<f32>> =
+            (0..50).map(|_| generate_random_embedding(128)).collect();
 
         // Add an anomaly (very low norm)
         embeddings.push(vec![0.001; 128]);
@@ -1005,15 +1021,11 @@ mod tests {
         let mut debugger = EmbeddingDebugger::new(DebugConfig::default());
 
         // Set baseline
-        let baseline: Vec<Vec<f32>> = (0..100)
-            .map(|_| generate_random_embedding(128))
-            .collect();
+        let baseline: Vec<Vec<f32>> = (0..100).map(|_| generate_random_embedding(128)).collect();
         debugger.set_baseline(&baseline).unwrap();
 
         // Check similar embeddings (no drift)
-        let similar: Vec<Vec<f32>> = (0..50)
-            .map(|_| generate_random_embedding(128))
-            .collect();
+        let similar: Vec<Vec<f32>> = (0..50).map(|_| generate_random_embedding(128)).collect();
         let report = debugger.check_drift(&similar).unwrap();
 
         println!("Drift score: {}", report.overall_drift_score);
diff --git a/src/deduplication.rs b/src/deduplication.rs
index 985b9a7..a19b5ca 100644
--- a/src/deduplication.rs
+++ b/src/deduplication.rs
@@ -234,10 +234,10 @@ impl Deduplicator {
                 DeduplicationStrategy::KeepLast => group.duplicates.last().unwrap(),
                 DeduplicationStrategy::KeepMostMetadata => {
                     self.select_most_metadata(&group.duplicates, store)?
-                }
+                },
                 DeduplicationStrategy::KeepHighestQuality => {
                     self.select_highest_quality(&group.duplicates, store)?
-                }
+                },
             };
 
             // Remove all except the one to keep
diff --git a/src/dim_reduction.rs b/src/dim_reduction.rs
index 44b7589..e604ef3 100644
--- a/src/dim_reduction.rs
+++ b/src/dim_reduction.rs
@@ -28,7 +28,7 @@
 //! assert_eq!(reduced[0].len(), 2);
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 
 /// Principal Component Analysis (PCA)
diff --git a/src/discovery.rs b/src/discovery.rs
index 3e5e520..09e20ba 100644
--- a/src/discovery.rs
+++ b/src/discovery.rs
@@ -257,7 +257,12 @@ impl DiscoveryIndex {
     }
 
     /// Insert vector
-    pub fn insert(&self, id: &str, vector: &[f32], metadata: HashMap<String, serde_json::Value>) -> Result<()> {
+    pub fn insert(
+        &self,
+        id: &str,
+        vector: &[f32],
+        metadata: HashMap<String, serde_json::Value>,
+    ) -> Result<()> {
         if vector.len() != self.config.dimension {
             return Err(VecStoreError::DimensionMismatch {
                 expected: self.config.dimension,
@@ -265,12 +270,14 @@ impl DiscoveryIndex {
             });
         }
 
-        let mut vectors = self.vectors.write()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on vectors".into()))?;
+        let mut vectors = self.vectors.write().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire write lock on vectors".into())
+        })?;
         vectors.insert(id.to_string(), vector.to_vec());
 
-        let mut meta = self.metadata.write()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on metadata".into()))?;
+        let mut meta = self.metadata.write().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire write lock on metadata".into())
+        })?;
         meta.insert(id.to_string(), metadata);
 
         Ok(())
@@ -278,33 +285,41 @@ impl DiscoveryIndex {
 
     /// Get vector by ID
     pub fn get(&self, id: &str) -> Option<Vec<f32>> {
-        let Ok(vectors) = self.vectors.read() else { return None; };
+        let Ok(vectors) = self.vectors.read() else {
+            return None;
+        };
         vectors.get(id).cloned()
     }
 
     /// Execute discovery query
     pub fn discover(&self, query: DiscoveryQuery) -> Result<Vec<DiscoveryResult>> {
-        let vectors = self.vectors.read()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire read lock on vectors".into()))?;
-        let metadata = self.metadata.read()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire read lock on metadata".into()))?;
+        let vectors = self.vectors.read().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire read lock on vectors".into())
+        })?;
+        let metadata = self.metadata.read().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire read lock on metadata".into())
+        })?;
 
         // Get positive vectors
-        let positive_vecs: Vec<Vec<f32>> = query.positive_ids
+        let positive_vecs: Vec<Vec<f32>> = query
+            .positive_ids
             .iter()
             .filter_map(|id| vectors.get(id).cloned())
             .chain(query.positive_vectors.clone())
             .collect();
 
         // Get negative vectors
-        let negative_vecs: Vec<Vec<f32>> = query.negative_ids
+        let negative_vecs: Vec<Vec<f32>> = query
+            .negative_ids
             .iter()
             .filter_map(|id| vectors.get(id).cloned())
             .chain(query.negative_vectors.clone())
             .collect();
 
         // Exclude positive and negative IDs from results
-        let exclude_ids: HashSet<&str> = query.positive_ids.iter()
+        let exclude_ids: HashSet<&str> = query
+            .positive_ids
+            .iter()
             .chain(&query.negative_ids)
             .map(|s| s.as_str())
             .collect();
@@ -315,22 +330,28 @@ impl DiscoveryIndex {
             .filter(|(id, _)| !exclude_ids.contains(id.as_str()))
             .map(|(id, vec)| {
                 let pos_score = if !positive_vecs.is_empty() {
-                    positive_vecs.iter()
+                    positive_vecs
+                        .iter()
                         .map(|pv| cosine_similarity(vec, pv))
-                        .sum::<f32>() / positive_vecs.len() as f32
+                        .sum::<f32>()
+                        / positive_vecs.len() as f32
                 } else {
                     0.0
                 };
 
                 let neg_score = if !negative_vecs.is_empty() {
-                    negative_vecs.iter()
+                    negative_vecs
+                        .iter()
                         .map(|nv| cosine_similarity(vec, nv))
-                        .sum::<f32>() / negative_vecs.len() as f32
+                        .sum::<f32>()
+                        / negative_vecs.len() as f32
                 } else {
                     0.0
                 };
 
-                let target_score = query.target.as_ref()
+                let target_score = query
+                    .target
+                    .as_ref()
                     .map(|t| cosine_similarity(vec, t))
                     .unwrap_or(0.0);
 
@@ -338,23 +359,18 @@ impl DiscoveryIndex {
                 let score = match query.mode {
                     DiscoveryMode::Context => {
                         pos_score * query.positive_weight - neg_score * query.negative_weight
-                    }
+                    },
                     DiscoveryMode::Discover => {
                         // Maximize novelty (low similarity to all examples)
                         let all_sim = (pos_score + neg_score) / 2.0;
                         1.0 - all_sim
-                    }
-                    DiscoveryMode::Recommend => {
-                        pos_score * query.positive_weight
-                    }
-                    DiscoveryMode::Contrast => {
-                        -neg_score * query.negative_weight
-                    }
+                    },
+                    DiscoveryMode::Recommend => pos_score * query.positive_weight,
+                    DiscoveryMode::Contrast => -neg_score * query.negative_weight,
                     DiscoveryMode::Blend => {
-                        pos_score * query.positive_weight
-                            - neg_score * query.negative_weight
+                        pos_score * query.positive_weight - neg_score * query.negative_weight
                             + target_score * 0.5
-                    }
+                    },
                 };
 
                 DiscoveryResult {
@@ -406,7 +422,8 @@ impl DiscoveryIndex {
                     let diversity_penalty = if selected_vecs.is_empty() {
                         0.0
                     } else {
-                        selected_vecs.iter()
+                        selected_vecs
+                            .iter()
                             .map(|sv| cosine_similarity(vec, sv))
                             .fold(f32::NEG_INFINITY, f32::max)
                     };
@@ -434,13 +451,21 @@ impl DiscoveryIndex {
     }
 
     /// Explore from a starting point
-    pub fn explore(&self, start_id: &str, radius: f32, max_results: usize) -> Result<Vec<DiscoveryResult>> {
-        let vectors = self.vectors.read()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire read lock on vectors".into()))?;
-        let metadata = self.metadata.read()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire read lock on metadata".into()))?;
-
-        let start_vec = vectors.get(start_id)
+    pub fn explore(
+        &self,
+        start_id: &str,
+        radius: f32,
+        max_results: usize,
+    ) -> Result<Vec<DiscoveryResult>> {
+        let vectors = self.vectors.read().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire read lock on vectors".into())
+        })?;
+        let metadata = self.metadata.read().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire read lock on metadata".into())
+        })?;
+
+        let start_vec = vectors
+            .get(start_id)
             .ok_or_else(|| VecStoreError::NotFound(start_id.to_string()))?;
 
         let mut results: Vec<DiscoveryResult> = vectors
@@ -470,8 +495,12 @@ impl DiscoveryIndex {
 
     /// Find boundary vectors (transition points between clusters)
     pub fn find_boundaries(&self, num_boundaries: usize) -> Vec<DiscoveryResult> {
-        let Ok(vectors) = self.vectors.read() else { return Vec::new(); };
-        let Ok(metadata) = self.metadata.read() else { return Vec::new(); };
+        let Ok(vectors) = self.vectors.read() else {
+            return Vec::new();
+        };
+        let Ok(metadata) = self.metadata.read() else {
+            return Vec::new();
+        };
 
         if vectors.len() < 3 {
             return Vec::new();
@@ -496,7 +525,8 @@ impl DiscoveryIndex {
             if k > 0 {
                 let top_k: Vec<f32> = similarities.into_iter().take(k).collect();
                 let mean: f32 = top_k.iter().sum::<f32>() / k as f32;
-                let variance: f32 = top_k.iter().map(|s| (s - mean).powi(2)).sum::<f32>() / k as f32;
+                let variance: f32 =
+                    top_k.iter().map(|s| (s - mean).powi(2)).sum::<f32>() / k as f32;
 
                 // Boundary score = variance (high variance = boundary)
                 boundary_scores.push((id.to_string(), variance));
@@ -542,11 +572,8 @@ impl DiscoveryIndex {
         let vec_list: Vec<(&String, &Vec<f32>)> = vectors.iter().collect();
 
         // Initialize centroids (first k vectors)
-        let mut centroids: Vec<Vec<f32>> = vec_list
-            .iter()
-            .take(k)
-            .map(|(_, v)| (*v).clone())
-            .collect();
+        let mut centroids: Vec<Vec<f32>> =
+            vec_list.iter().take(k).map(|(_, v)| (*v).clone()).collect();
 
         // Run k-means for a few iterations
         let mut assignments: Vec<usize> = vec![0; vec_list.len()];
@@ -623,9 +650,9 @@ impl DiscoveryIndex {
                 let mut member_sims: Vec<(String, f32)> = members
                     .iter()
                     .filter_map(|id| {
-                        vectors.get(id).map(|v| {
-                            (id.clone(), cosine_similarity(v, centroid))
-                        })
+                        vectors
+                            .get(id)
+                            .map(|v| (id.clone(), cosine_similarity(v, centroid)))
                     })
                     .collect();
 
@@ -655,7 +682,11 @@ impl DiscoveryIndex {
             }
         }
 
-        let diversity_score = if count > 0 { total_dist / count as f32 } else { 0.0 };
+        let diversity_score = if count > 0 {
+            total_dist / count as f32
+        } else {
+            0.0
+        };
 
         ExplorationResult {
             regions,
@@ -719,15 +750,28 @@ mod tests {
 
     #[test]
     fn test_discovery_context() {
-        let config = DiscoveryConfig { dimension: 4, ..Default::default() };
+        let config = DiscoveryConfig {
+            dimension: 4,
+            ..Default::default()
+        };
         let index = DiscoveryIndex::new(config);
 
         // Insert vectors
-        index.insert("pos1", &[1.0, 0.0, 0.0, 0.0], HashMap::new()).unwrap();
-        index.insert("pos2", &[0.9, 0.1, 0.0, 0.0], HashMap::new()).unwrap();
-        index.insert("neg1", &[0.0, 0.0, 1.0, 0.0], HashMap::new()).unwrap();
-        index.insert("candidate1", &[0.8, 0.2, 0.0, 0.0], HashMap::new()).unwrap();
-        index.insert("candidate2", &[0.0, 0.0, 0.8, 0.2], HashMap::new()).unwrap();
+        index
+            .insert("pos1", &[1.0, 0.0, 0.0, 0.0], HashMap::new())
+            .unwrap();
+        index
+            .insert("pos2", &[0.9, 0.1, 0.0, 0.0], HashMap::new())
+            .unwrap();
+        index
+            .insert("neg1", &[0.0, 0.0, 1.0, 0.0], HashMap::new())
+            .unwrap();
+        index
+            .insert("candidate1", &[0.8, 0.2, 0.0, 0.0], HashMap::new())
+            .unwrap();
+        index
+            .insert("candidate2", &[0.0, 0.0, 0.8, 0.2], HashMap::new())
+            .unwrap();
 
         // Context search
         let query = DiscoveryQuery::new()
@@ -743,12 +787,18 @@ mod tests {
 
     #[test]
     fn test_discovery_with_diversity() {
-        let config = DiscoveryConfig { dimension: 4, enable_mmr: true, ..Default::default() };
+        let config = DiscoveryConfig {
+            dimension: 4,
+            enable_mmr: true,
+            ..Default::default()
+        };
         let index = DiscoveryIndex::new(config);
 
         for i in 0..10 {
             let vec = vec![(i as f32) / 10.0, 1.0 - (i as f32) / 10.0, 0.0, 0.0];
-            index.insert(&format!("vec_{}", i), &vec, HashMap::new()).unwrap();
+            index
+                .insert(&format!("vec_{}", i), &vec, HashMap::new())
+                .unwrap();
         }
 
         let query = DiscoveryQuery::new()
@@ -762,13 +812,24 @@ mod tests {
 
     #[test]
     fn test_explore() {
-        let config = DiscoveryConfig { dimension: 4, ..Default::default() };
+        let config = DiscoveryConfig {
+            dimension: 4,
+            ..Default::default()
+        };
         let index = DiscoveryIndex::new(config);
 
-        index.insert("center", &[1.0, 0.0, 0.0, 0.0], HashMap::new()).unwrap();
-        index.insert("near1", &[0.95, 0.05, 0.0, 0.0], HashMap::new()).unwrap();
-        index.insert("near2", &[0.9, 0.1, 0.0, 0.0], HashMap::new()).unwrap();
-        index.insert("far", &[0.0, 1.0, 0.0, 0.0], HashMap::new()).unwrap();
+        index
+            .insert("center", &[1.0, 0.0, 0.0, 0.0], HashMap::new())
+            .unwrap();
+        index
+            .insert("near1", &[0.95, 0.05, 0.0, 0.0], HashMap::new())
+            .unwrap();
+        index
+            .insert("near2", &[0.9, 0.1, 0.0, 0.0], HashMap::new())
+            .unwrap();
+        index
+            .insert("far", &[0.0, 1.0, 0.0, 0.0], HashMap::new())
+            .unwrap();
 
         let results = index.explore("center", 0.2, 10).unwrap();
 
@@ -789,12 +850,16 @@ mod tests {
         // Create two clusters
         for i in 0..5 {
             let vec = vec![1.0 - (i as f32) * 0.05, (i as f32) * 0.05, 0.0, 0.0];
-            index.insert(&format!("cluster1_{}", i), &vec, HashMap::new()).unwrap();
+            index
+                .insert(&format!("cluster1_{}", i), &vec, HashMap::new())
+                .unwrap();
         }
 
         for i in 0..5 {
             let vec = vec![0.0, 0.0, 1.0 - (i as f32) * 0.05, (i as f32) * 0.05];
-            index.insert(&format!("cluster2_{}", i), &vec, HashMap::new()).unwrap();
+            index
+                .insert(&format!("cluster2_{}", i), &vec, HashMap::new())
+                .unwrap();
         }
 
         let exploration = index.find_clusters();
@@ -805,12 +870,21 @@ mod tests {
 
     #[test]
     fn test_discovery_modes() {
-        let config = DiscoveryConfig { dimension: 4, ..Default::default() };
+        let config = DiscoveryConfig {
+            dimension: 4,
+            ..Default::default()
+        };
         let index = DiscoveryIndex::new(config);
 
-        index.insert("v1", &[1.0, 0.0, 0.0, 0.0], HashMap::new()).unwrap();
-        index.insert("v2", &[0.0, 1.0, 0.0, 0.0], HashMap::new()).unwrap();
-        index.insert("v3", &[0.0, 0.0, 1.0, 0.0], HashMap::new()).unwrap();
+        index
+            .insert("v1", &[1.0, 0.0, 0.0, 0.0], HashMap::new())
+            .unwrap();
+        index
+            .insert("v2", &[0.0, 1.0, 0.0, 0.0], HashMap::new())
+            .unwrap();
+        index
+            .insert("v3", &[0.0, 0.0, 1.0, 0.0], HashMap::new())
+            .unwrap();
 
         // Discover mode (novelty)
         let query = DiscoveryQuery::new()
diff --git a/src/diskann.rs b/src/diskann.rs
index e796d49..536f058 100644
--- a/src/diskann.rs
+++ b/src/diskann.rs
@@ -53,8 +53,8 @@ use std::collections::{BinaryHeap, HashMap, HashSet};
 use std::fs::File;
 use std::io::{BufReader, BufWriter};
 use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::RwLock;
+use std::sync::atomic::{AtomicU64, Ordering};
 
 /// DiskANN configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -163,10 +163,8 @@ impl PQQuantizer {
             let end = start + self.subvector_dim;
 
             // Extract subvectors
-            let subvectors: Vec<Vec<f32>> = vectors
-                .iter()
-                .map(|v| v[start..end].to_vec())
-                .collect();
+            let subvectors: Vec<Vec<f32>> =
+                vectors.iter().map(|v| v[start..end].to_vec()).collect();
 
             // K-means clustering
             let centroids = self.kmeans(&subvectors, self.num_centroids, iterations)?;
@@ -527,7 +525,8 @@ impl DiskANN {
             let node_vec = &vectors[node_idx];
 
             // Greedy search to find candidates
-            let candidates = self.greedy_search_build(vectors, node_vec, self.config.build_beam_width)?;
+            let candidates =
+                self.greedy_search_build(vectors, node_vec, self.config.build_beam_width)?;
 
             // RobustPrune to select neighbors
             let neighbors = self.robust_prune(vectors, node_id, &candidates)?;
@@ -549,8 +548,8 @@ impl DiskANN {
 
                 // Prune if over max degree (done outside the mutable borrow)
                 if needs_prune {
-                    let candidates: Vec<u64> = self.graph.get(&neighbor_id).cloned()
-                        .unwrap_or_default();
+                    let candidates: Vec<u64> =
+                        self.graph.get(&neighbor_id).cloned().unwrap_or_default();
                     let pruned = self.robust_prune(vectors, neighbor_id, &candidates)?;
                     self.graph.insert(neighbor_id, pruned);
                 }
@@ -587,9 +586,11 @@ impl DiskANN {
         while let Some(current) = candidates.pop() {
             // Check if we can stop
             if let Some(std::cmp::Reverse(worst)) = results.peek()
-                && current.distance > worst.distance && results.len() >= beam_width {
-                    break;
-                }
+                && current.distance > worst.distance
+                && results.len() >= beam_width
+            {
+                break;
+            }
 
             // Explore neighbors
             if let Some(neighbors) = self.graph.get(&current.id) {
@@ -674,7 +675,12 @@ impl DiskANN {
 
     /// Search for k nearest neighbors
     #[inline]
-    pub fn search(&self, query: &[f32], k: usize, beam_width: Option<usize>) -> Result<Vec<DiskANNResult>> {
+    pub fn search(
+        &self,
+        query: &[f32],
+        k: usize,
+        beam_width: Option<usize>,
+    ) -> Result<Vec<DiskANNResult>> {
         self.stats.total_searches.fetch_add(1, Ordering::Relaxed);
 
         let beam = beam_width.unwrap_or(self.config.search_beam_width);
@@ -713,15 +719,19 @@ impl DiskANN {
 
             // Check stopping condition
             if let Some(std::cmp::Reverse(worst)) = results.peek()
-                && current.distance > worst.distance && results.len() >= beam {
-                    continue;
-                }
+                && current.distance > worst.distance
+                && results.len() >= beam
+            {
+                continue;
+            }
 
             // Explore neighbors using PQ distances
             if let Some(neighbors) = self.graph.get(&current.id) {
                 for &neighbor_id in neighbors {
                     if visited.insert(neighbor_id) {
-                        self.stats.distance_computations.fetch_add(1, Ordering::Relaxed);
+                        self.stats
+                            .distance_computations
+                            .fetch_add(1, Ordering::Relaxed);
 
                         let dist = if let Some(codes) = self.pq_codes.get(&neighbor_id) {
                             self.quantizer.table_distance(&pq_table, codes)
@@ -1099,6 +1109,10 @@ mod tests {
 
         let recall = correct as f64 / (test_count * 10) as f64;
         println!("Recall@10: {:.2}%", recall * 100.0);
-        assert!(recall > 0.70, "Recall should be > 70%, got {:.2}%", recall * 100.0);
+        assert!(
+            recall > 0.70,
+            "Recall should be > 70%, got {:.2}%",
+            recall * 100.0
+        );
     }
 }
diff --git a/src/distributed/mod.rs b/src/distributed/mod.rs
index eda55de..561b423 100644
--- a/src/distributed/mod.rs
+++ b/src/distributed/mod.rs
@@ -444,7 +444,7 @@ impl DistributedStore {
                 let mut hasher = DefaultHasher::new();
                 key.hash(&mut hasher);
                 (hasher.finish() as usize) % self.config.num_shards
-            }
+            },
             ShardingStrategy::ConsistentHash => {
                 // Use consistent hash ring
                 let node = self.hash_ring.get_node(key).unwrap_or_default();
@@ -454,15 +454,15 @@ impl DistributedStore {
                     .iter()
                     .fold(0u32, |acc, &b| acc.wrapping_add(b as u32));
                 (sum as usize) % self.config.num_shards
-            }
+            },
             ShardingStrategy::Range => {
                 // Range-based (simplified - would use key ranges in production)
                 key.as_bytes().first().copied().unwrap_or(0) as usize % self.config.num_shards
-            }
+            },
             ShardingStrategy::Random => {
                 // Random (simplified)
                 key.len() % self.config.num_shards
-            }
+            },
         }
     }
 
@@ -720,7 +720,7 @@ impl DistributedStore {
                 let mut hasher = DefaultHasher::new();
                 key.hash(&mut hasher);
                 (hasher.finish() as usize) % self.config.num_shards
-            }
+            },
             ShardingStrategy::ConsistentHash => {
                 let ring = self.hash_ring.read().await;
                 let node = ring.get_node(key).unwrap_or_default();
@@ -729,10 +729,10 @@ impl DistributedStore {
                     .iter()
                     .fold(0u32, |acc, &b| acc.wrapping_add(b as u32));
                 (sum as usize) % self.config.num_shards
-            }
+            },
             ShardingStrategy::Range => {
                 key.as_bytes().first().copied().unwrap_or(0) as usize % self.config.num_shards
-            }
+            },
             ShardingStrategy::Random => key.len() % self.config.num_shards,
         }
     }
@@ -826,18 +826,18 @@ impl DistributedStore {
                     // Simulate sync latency
                     // In production: await network RPC
                 }
-            }
+            },
             ConsistencyLevel::Quorum => {
                 // Wait for majority (N/2 + 1)
                 let quorum_size = (replicas.len() / 2) + 1;
                 for _i in 0..quorum_size {
                     // Simulate sync to quorum
                 }
-            }
+            },
             ConsistencyLevel::One => {
                 // Fire and forget - don't wait for acknowledgment
                 // Replicas will eventually sync
-            }
+            },
         }
 
         Ok(())
@@ -872,18 +872,18 @@ impl DistributedStore {
                 // Always query primary for strong consistency
                 // In real implementation: send RPC to primary node
                 Ok(vec![])
-            }
+            },
             ConsistencyLevel::Quorum => {
                 // Query quorum of nodes and return most recent results
                 // In real implementation: scatter to quorum, gather results
                 Ok(vec![])
-            }
+            },
             ConsistencyLevel::One => {
                 // Query any available replica (round-robin or least loaded)
                 // For now, use the first available replica
                 // In real implementation: check node health and load
                 Ok(vec![])
-            }
+            },
         }
     }
 
diff --git a/src/distributed/raft.rs b/src/distributed/raft.rs
index 964e5ff..089d4f8 100644
--- a/src/distributed/raft.rs
+++ b/src/distributed/raft.rs
@@ -13,7 +13,7 @@ use tokio::time;
 use tracing::{debug, error, info, warn};
 
 #[cfg(feature = "server")]
-use tonic::{transport::Channel, Request, Response, Status};
+use tonic::{Request, Response, Status, transport::Channel};
 
 #[cfg(feature = "server")]
 pub mod pb {
@@ -349,9 +349,9 @@ mod rpc {
             // Configure TLS if enabled
             if self.config.tls_enabled {
                 if let Some(ca_path) = &self.config.tls_ca_path {
-                    let ca_cert = tokio::fs::read(ca_path)
-                        .await
-                        .map_err(|e| RpcError::TlsError(format!("Failed to read CA cert: {}", e)))?;
+                    let ca_cert = tokio::fs::read(ca_path).await.map_err(|e| {
+                        RpcError::TlsError(format!("Failed to read CA cert: {}", e))
+                    })?;
                     let ca = Certificate::from_pem(ca_cert);
 
                     let tls_config = ClientTlsConfig::new().ca_certificate(ca);
@@ -410,12 +410,12 @@ mod rpc {
                     Ok(response) => {
                         self.mark_connection_success(node_id).await;
                         return Ok(response);
-                    }
+                    },
                     Err(e) => {
                         warn!("RequestVote to {} failed: {:?}", node_id, e);
                         self.mark_connection_failed(node_id).await;
                         last_error = Some(e);
-                    }
+                    },
                 }
             }
 
@@ -474,12 +474,12 @@ mod rpc {
                     Ok(response) => {
                         self.mark_connection_success(node_id).await;
                         return Ok(response);
-                    }
+                    },
                     Err(e) => {
                         warn!("AppendEntries to {} failed: {:?}", node_id, e);
                         self.mark_connection_failed(node_id).await;
                         last_error = Some(e);
-                    }
+                    },
                 }
             }
 
@@ -494,11 +494,8 @@ mod rpc {
         ) -> Result<AppendEntriesResponse, RpcError> {
             let mut client = self.get_connection(node_id).await?;
 
-            let pb_entries: Vec<pb::LogEntry> = request
-                .entries
-                .iter()
-                .map(|e| log_entry_to_pb(e))
-                .collect();
+            let pb_entries: Vec<pb::LogEntry> =
+                request.entries.iter().map(|e| log_entry_to_pb(e)).collect();
 
             let pb_request = pb::AppendEntriesRequest {
                 term: request.term,
@@ -620,7 +617,7 @@ mod rpc {
                 RpcError::RpcFailed(msg) => write!(f, "RPC failed: {}", msg),
                 RpcError::DeserializationFailed(msg) => {
                     write!(f, "Deserialization failed: {}", msg)
-                }
+                },
                 RpcError::MaxRetriesExceeded => write!(f, "Max retries exceeded"),
                 RpcError::Timeout => write!(f, "RPC timeout"),
             }
@@ -648,7 +645,11 @@ impl StateMachine {
     /// Apply a command to the state machine
     pub fn apply(&mut self, command: &Command) -> Option<Vec<u8>> {
         match command {
-            Command::Insert { id, vector, metadata } => {
+            Command::Insert {
+                id,
+                vector,
+                metadata,
+            } => {
                 let entry = serde_json::json!({
                     "vector": vector,
                     "metadata": metadata,
@@ -656,12 +657,16 @@ impl StateMachine {
                 let bytes = serde_json::to_vec(&entry).unwrap_or_default();
                 self.data.insert(id.clone(), bytes);
                 None
-            }
+            },
             Command::Delete { id } => {
                 self.data.remove(id);
                 None
-            }
-            Command::Update { id, vector, metadata } => {
+            },
+            Command::Update {
+                id,
+                vector,
+                metadata,
+            } => {
                 let entry = serde_json::json!({
                     "vector": vector,
                     "metadata": metadata,
@@ -669,7 +674,7 @@ impl StateMachine {
                 let bytes = serde_json::to_vec(&entry).unwrap_or_default();
                 self.data.insert(id.clone(), bytes);
                 None
-            }
+            },
             Command::NoOp => None,
         }
     }
@@ -882,7 +887,9 @@ impl RaftNode {
         T: serde::de::DeserializeOwned,
     {
         let state_machine = self.state_machine.read().await;
-        state_machine.get(key).and_then(|bytes| serde_json::from_slice(bytes).ok())
+        state_machine
+            .get(key)
+            .and_then(|bytes| serde_json::from_slice(bytes).ok())
     }
 
     /// Start an election
@@ -965,17 +972,17 @@ impl RaftNode {
                                 self.config.node_id, peer_id, votes, votes_needed
                             );
                         }
-                    }
+                    },
                     Ok(Ok((peer_id, Err(e)))) => {
                         warn!("Failed to get vote from {}: {:?}", peer_id, e);
-                    }
+                    },
                     Ok(Err(e)) => {
                         warn!("Vote task failed: {:?}", e);
-                    }
+                    },
                     Err(_) => {
                         debug!("Vote collection timed out");
                         break;
-                    }
+                    },
                 }
             }
         }
@@ -1150,8 +1157,7 @@ impl RaftNode {
                             if let Some(ls) = leader_state.as_mut() {
                                 if response.success {
                                     // Update next_index and match_index
-                                    ls.match_index
-                                        .insert(peer_id.clone(), response.match_index);
+                                    ls.match_index.insert(peer_id.clone(), response.match_index);
                                     ls.next_index
                                         .insert(peer_id.clone(), response.match_index + 1);
 
@@ -1171,10 +1177,10 @@ impl RaftNode {
                                     debug!("AppendEntries to {} failed, will retry", peer_id);
                                 }
                             }
-                        }
+                        },
                         Err(e) => {
                             warn!("Failed to send heartbeat to {}: {:?}", peer_id, e);
-                        }
+                        },
                     }
                 }));
             }
@@ -1422,8 +1428,9 @@ impl RaftNode {
     fn random_election_timeout(&self) -> Duration {
         use rand::Rng;
         let mut rng = rand::rng();
-        let timeout_ms = rng
-            .random_range(self.config.election_timeout_min_ms..=self.config.election_timeout_max_ms);
+        let timeout_ms = rng.random_range(
+            self.config.election_timeout_min_ms..=self.config.election_timeout_max_ms,
+        );
         Duration::from_millis(timeout_ms)
     }
 
@@ -1592,8 +1599,11 @@ pub mod server {
             let req = request.into_inner();
 
             // Convert protobuf log entries
-            let entries: Result<Vec<LogEntry>, _> =
-                req.entries.iter().map(|e| rpc::pb_to_log_entry(e)).collect();
+            let entries: Result<Vec<LogEntry>, _> = req
+                .entries
+                .iter()
+                .map(|e| rpc::pb_to_log_entry(e))
+                .collect();
 
             let entries = entries.map_err(|e| Status::invalid_argument(format!("{}", e)))?;
 
@@ -1716,7 +1726,7 @@ pub mod server {
 }
 
 #[cfg(feature = "server")]
-pub use server::{start_raft_server, RaftGrpcService};
+pub use server::{RaftGrpcService, start_raft_server};
 
 // ============================================================================
 // Cluster Membership Management
@@ -1928,8 +1938,7 @@ impl FailoverManager {
     /// Update known leader
     pub async fn set_leader(&self, leader: NodeId) {
         *self.current_leader.write().await = Some(leader);
-        self.failures
-            .store(0, std::sync::atomic::Ordering::Relaxed);
+        self.failures.store(0, std::sync::atomic::Ordering::Relaxed);
     }
 
     /// Get current leader
@@ -1939,10 +1948,10 @@ impl FailoverManager {
 
     /// Report a failure
     pub async fn report_failure(&self) -> bool {
-        let failures =
-            self.failures
-                .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
-                + 1;
+        let failures = self
+            .failures
+            .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+            + 1;
 
         if failures >= self.config.max_retries {
             // Trigger leader discovery
@@ -2014,7 +2023,7 @@ impl ReplicationCoordinator {
                     }
                     // Would normally redirect to leader here
                     time::sleep(Duration::from_millis(100)).await;
-                }
+                },
                 Err(e) => return Err(e),
             }
         }
@@ -2037,12 +2046,12 @@ impl ReplicationCoordinator {
                 }
                 // Read from leader's state machine
                 Ok(self.node.read_from_state_machine(key).await)
-            }
+            },
             ReadConsistency::Any => {
                 // Any read: Read from local state machine regardless of leader status
                 // May return stale data if this node is behind
                 Ok(self.node.read_from_state_machine(key).await)
-            }
+            },
             ReadConsistency::Linearizable => {
                 // Linearizable read: Strongest guarantee - verify leadership before reading
                 if !self.node.is_leader().await {
@@ -2058,7 +2067,7 @@ impl ReplicationCoordinator {
 
                 // Now safe to read - we confirmed we're still the leader
                 Ok(self.node.read_from_state_machine(key).await)
-            }
+            },
             ReadConsistency::Quorum => {
                 // Quorum read: Read from majority of nodes and return most recent
                 // For now, if we're leader, we know we have the most up-to-date data
@@ -2071,7 +2080,7 @@ impl ReplicationCoordinator {
                     // For now, read local and indicate it may be stale
                     Ok(self.node.read_from_state_machine(key).await)
                 }
-            }
+            },
         }
     }
 
@@ -2177,10 +2186,10 @@ impl ReplicationCoordinator {
         match change {
             MembershipChange::AddNode(node_id) => {
                 config.members.insert(node_id);
-            }
+            },
             MembershipChange::RemoveNode(node_id) => {
                 config.members.remove(&node_id);
-            }
+            },
         }
 
         config.version += 1;
diff --git a/src/dynamic_schema.rs b/src/dynamic_schema.rs
index 83202bf..51e26be 100644
--- a/src/dynamic_schema.rs
+++ b/src/dynamic_schema.rs
@@ -37,12 +37,12 @@
 //! collection.search_with_filter(&query, "score > 0.9")?;
 //! ```
 
-use std::collections::HashMap;
-use std::sync::RwLock;
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
+use std::collections::HashMap;
+use std::sync::RwLock;
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 // ============================================================================
 // FIELD TYPES
@@ -83,7 +83,7 @@ impl FieldType {
                 } else {
                     FieldType::Float64
                 }
-            }
+            },
             JsonValue::String(_) => FieldType::String,
             JsonValue::Array(arr) => {
                 if arr.is_empty() {
@@ -94,7 +94,7 @@ impl FieldType {
                     let elem_type = FieldType::infer(&arr[0]);
                     FieldType::Array(Box::new(elem_type))
                 }
-            }
+            },
             JsonValue::Object(_) => FieldType::Object,
         }
     }
@@ -111,7 +111,7 @@ impl FieldType {
             (FieldType::Array(_), JsonValue::Array(_)) => true,
             (FieldType::Vector(dim), JsonValue::Array(arr)) => {
                 arr.len() == *dim && arr.iter().all(|v| v.is_f64())
-            }
+            },
             (FieldType::Timestamp, JsonValue::Number(_)) => true,
             (FieldType::Timestamp, JsonValue::String(_)) => true,
             _ => false,
@@ -230,7 +230,9 @@ impl Schema {
 
             Ok(())
         } else {
-            Err(VecStoreError::InvalidInput("Document must be an object".to_string()))
+            Err(VecStoreError::InvalidInput(
+                "Document must be an object".to_string(),
+            ))
         }
     }
 
@@ -268,7 +270,8 @@ impl SchemaBuilder {
 
     #[inline]
     pub fn add_field(mut self, name: &str, field_type: FieldType) -> Self {
-        self.fields.insert(name.to_string(), FieldDef::new(name, field_type));
+        self.fields
+            .insert(name.to_string(), FieldDef::new(name, field_type));
         self
     }
 
@@ -371,7 +374,9 @@ impl SchemaEvolution {
     /// Apply a schema change
     pub fn apply(&mut self, change: SchemaChange) -> Result<Schema> {
         let current_version = *self.versions.keys().max().unwrap_or(&0);
-        let mut new_schema = self.versions.get(&current_version)
+        let mut new_schema = self
+            .versions
+            .get(&current_version)
             .ok_or_else(|| VecStoreError::Internal("No current schema".to_string()))?
             .clone();
 
@@ -384,7 +389,7 @@ impl SchemaEvolution {
                     )));
                 }
                 new_schema.fields.insert(field.name.clone(), field.clone());
-            }
+            },
             SchemaChange::FieldRemoved { name } => {
                 if !new_schema.fields.contains_key(name) {
                     return Err(VecStoreError::InvalidInput(format!(
@@ -393,7 +398,7 @@ impl SchemaEvolution {
                     )));
                 }
                 new_schema.fields.remove(name);
-            }
+            },
             SchemaChange::FieldTypeChanged { name, from, to } => {
                 if let Some(field) = new_schema.fields.get_mut(name) {
                     if field.field_type != *from {
@@ -410,27 +415,27 @@ impl SchemaEvolution {
                     }
                     field.field_type = to.clone();
                 }
-            }
+            },
             SchemaChange::FieldNullable { name } => {
                 if let Some(field) = new_schema.fields.get_mut(name) {
                     field.nullable = true;
                 }
-            }
+            },
             SchemaChange::FieldRequired { name } => {
                 if let Some(field) = new_schema.fields.get_mut(name) {
                     field.nullable = false;
                 }
-            }
+            },
             SchemaChange::IndexAdded { field } => {
                 if let Some(f) = new_schema.fields.get_mut(field) {
                     f.indexed = true;
                 }
-            }
+            },
             SchemaChange::IndexRemoved { field } => {
                 if let Some(f) = new_schema.fields.get_mut(field) {
                     f.indexed = false;
                 }
-            }
+            },
         }
 
         new_schema.version = current_version + 1;
@@ -488,14 +493,18 @@ impl DynamicCollection {
     pub fn insert(&self, doc: JsonValue) -> Result<String> {
         // Validate against schema
         {
-            let schema = self.schema.read()
+            let schema = self
+                .schema
+                .read()
                 .map_err(|_| VecStoreError::Internal("Schema lock poisoned".to_string()))?;
             schema.validate(&doc)?;
         }
 
         // Extract ID
         let id = {
-            let schema = self.schema.read()
+            let schema = self
+                .schema
+                .read()
                 .map_err(|_| VecStoreError::Internal("Schema lock poisoned".to_string()))?;
             doc.get(&schema.primary_key)
                 .and_then(|v| v.as_str())
@@ -505,22 +514,29 @@ impl DynamicCollection {
 
         // Extract vector
         let vector = {
-            let schema = self.schema.read()
+            let schema = self
+                .schema
+                .read()
                 .map_err(|_| VecStoreError::Internal("Schema lock poisoned".to_string()))?;
             schema.extract_vector(&doc)
         };
 
         // Discover dynamic fields
         if let JsonValue::Object(map) = &doc {
-            let schema = self.schema.read()
+            let schema = self
+                .schema
+                .read()
                 .map_err(|_| VecStoreError::Internal("Schema lock poisoned".to_string()))?;
-            let mut dynamic = self.dynamic_fields.write()
+            let mut dynamic = self
+                .dynamic_fields
+                .write()
                 .map_err(|_| VecStoreError::Internal("Dynamic fields lock poisoned".to_string()))?;
 
             for (key, value) in map {
                 if !schema.fields.contains_key(key) {
                     let inferred_type = FieldType::infer(value);
-                    dynamic.entry(key.clone())
+                    dynamic
+                        .entry(key.clone())
                         .and_modify(|existing| {
                             // Promote type if needed
                             if !existing.is_compatible(value) {
@@ -533,13 +549,15 @@ impl DynamicCollection {
         }
 
         // Store document
-        self.documents.write()
+        self.documents
+            .write()
             .map_err(|_| VecStoreError::Internal("Documents lock poisoned".to_string()))?
             .insert(id.clone(), doc);
 
         // Store vector
         if let Some(vec) = vector {
-            self.vectors.write()
+            self.vectors
+                .write()
                 .map_err(|_| VecStoreError::Internal("Vectors lock poisoned".to_string()))?
                 .insert(id.clone(), vec);
         }
@@ -549,13 +567,17 @@ impl DynamicCollection {
 
     /// Get document by ID
     pub fn get(&self, id: &str) -> Option<JsonValue> {
-        let Ok(documents) = self.documents.read() else { return None; };
+        let Ok(documents) = self.documents.read() else {
+            return None;
+        };
         documents.get(id).cloned()
     }
 
     /// Delete document
     pub fn delete(&self, id: &str) -> bool {
-        let Ok(mut documents) = self.documents.write() else { return false; };
+        let Ok(mut documents) = self.documents.write() else {
+            return false;
+        };
         let doc_removed = documents.remove(id).is_some();
         drop(documents); // Release lock before acquiring next
         if let Ok(mut vectors) = self.vectors.write() {
@@ -567,10 +589,14 @@ impl DynamicCollection {
     /// Add a new field to schema
     pub fn add_field(&self, field: FieldDef) -> Result<()> {
         let change = SchemaChange::FieldAdded { field };
-        let new_schema = self.evolution.write()
+        let new_schema = self
+            .evolution
+            .write()
             .map_err(|_| VecStoreError::Internal("Evolution lock poisoned".to_string()))?
             .apply(change)?;
-        *self.schema.write()
+        *self
+            .schema
+            .write()
             .map_err(|_| VecStoreError::Internal("Schema lock poisoned".to_string()))? = new_schema;
         Ok(())
     }
@@ -578,9 +604,13 @@ impl DynamicCollection {
     /// Promote dynamic field to schema
     pub fn promote_field(&self, name: &str) -> Result<()> {
         let field_type = {
-            let dynamic = self.dynamic_fields.read()
+            let dynamic = self
+                .dynamic_fields
+                .read()
                 .map_err(|_| VecStoreError::Internal("Dynamic fields lock poisoned".to_string()))?;
-            dynamic.get(name).cloned()
+            dynamic
+                .get(name)
+                .cloned()
                 .ok_or_else(|| VecStoreError::NotFound(format!("Dynamic field: {}", name)))?
         };
 
@@ -588,7 +618,8 @@ impl DynamicCollection {
         self.add_field(field)?;
 
         // Remove from dynamic fields
-        self.dynamic_fields.write()
+        self.dynamic_fields
+            .write()
             .map_err(|_| VecStoreError::Internal("Dynamic fields lock poisoned".to_string()))?
             .remove(name);
 
@@ -596,20 +627,31 @@ impl DynamicCollection {
     }
 
     /// Search with filter
-    pub fn search(&self, query: &[f32], top_k: usize, filter: Option<&str>) -> Result<Vec<SearchResult>> {
-        let vectors = self.vectors.read()
+    pub fn search(
+        &self,
+        query: &[f32],
+        top_k: usize,
+        filter: Option<&str>,
+    ) -> Result<Vec<SearchResult>> {
+        let vectors = self
+            .vectors
+            .read()
             .map_err(|_| VecStoreError::Internal("Vectors lock poisoned".to_string()))?;
-        let documents = self.documents.read()
+        let documents = self
+            .documents
+            .read()
             .map_err(|_| VecStoreError::Internal("Documents lock poisoned".to_string()))?;
 
-        let mut results: Vec<_> = vectors.iter()
+        let mut results: Vec<_> = vectors
+            .iter()
             .filter_map(|(id, vec)| {
                 // Apply filter if provided
                 if let Some(filter_str) = filter
                     && let Some(doc) = documents.get(id)
-                        && !self.matches_filter(doc, filter_str) {
-                            return None;
-                        }
+                    && !self.matches_filter(doc, filter_str)
+                {
+                    return None;
+                }
 
                 let score = cosine_similarity(query, vec);
                 Some((id.clone(), score))
@@ -619,7 +661,8 @@ impl DynamicCollection {
         results.sort_by(|a, b| b.1.total_cmp(&a.1));
         results.truncate(top_k);
 
-        Ok(results.into_iter()
+        Ok(results
+            .into_iter()
             .map(|(id, score)| SearchResult { id, score })
             .collect())
     }
@@ -645,32 +688,32 @@ impl DynamicCollection {
                     if let Some(n) = field_value.as_f64() {
                         return n.to_string() == value;
                     }
-                }
+                },
                 ">" => {
                     if let (Some(v), Ok(threshold)) = (field_value.as_f64(), value.parse::<f64>()) {
                         return v > threshold;
                     }
-                }
+                },
                 "<" => {
                     if let (Some(v), Ok(threshold)) = (field_value.as_f64(), value.parse::<f64>()) {
                         return v < threshold;
                     }
-                }
+                },
                 ">=" => {
                     if let (Some(v), Ok(threshold)) = (field_value.as_f64(), value.parse::<f64>()) {
                         return v >= threshold;
                     }
-                }
+                },
                 "<=" => {
                     if let (Some(v), Ok(threshold)) = (field_value.as_f64(), value.parse::<f64>()) {
                         return v <= threshold;
                     }
-                }
+                },
                 "!=" => {
                     if let Some(s) = field_value.as_str() {
                         return s != value;
                     }
-                }
+                },
                 _ => return true,
             }
         }
@@ -769,7 +812,10 @@ mod tests {
         assert_eq!(FieldType::infer(&json!(42)), FieldType::Int64);
         assert_eq!(FieldType::infer(&json!(3.14)), FieldType::Float64);
         assert_eq!(FieldType::infer(&json!(true)), FieldType::Bool);
-        assert_eq!(FieldType::infer(&json!([1.0, 2.0, 3.0])), FieldType::Vector(3));
+        assert_eq!(
+            FieldType::infer(&json!([1.0, 2.0, 3.0])),
+            FieldType::Vector(3)
+        );
     }
 
     #[test]
@@ -783,12 +829,14 @@ mod tests {
         let collection = DynamicCollection::new(schema).unwrap();
 
         // Insert with dynamic fields
-        collection.insert(json!({
-            "id": "doc1",
-            "embedding": [1.0, 0.0, 0.0, 0.0],
-            "title": "Hello World",  // Dynamic field
-            "score": 0.95,           // Dynamic field
-        })).unwrap();
+        collection
+            .insert(json!({
+                "id": "doc1",
+                "embedding": [1.0, 0.0, 0.0, 0.0],
+                "title": "Hello World",  // Dynamic field
+                "score": 0.95,           // Dynamic field
+            }))
+            .unwrap();
 
         // Check dynamic fields discovered
         let dynamic = collection.dynamic_fields();
@@ -796,11 +844,9 @@ mod tests {
         assert!(dynamic.contains_key("score"));
 
         // Search with filter
-        let results = collection.search(
-            &[1.0, 0.0, 0.0, 0.0],
-            10,
-            Some("score > 0.9"),
-        ).unwrap();
+        let results = collection
+            .search(&[1.0, 0.0, 0.0, 0.0], 10, Some("score > 0.9"))
+            .unwrap();
 
         assert_eq!(results.len(), 1);
         assert_eq!(results[0].id, "doc1");
diff --git a/src/edge_runtime.rs b/src/edge_runtime.rs
index 88b474b..222fa12 100644
--- a/src/edge_runtime.rs
+++ b/src/edge_runtime.rs
@@ -33,10 +33,10 @@
 //! let state = store.to_bytes()?;
 //! ```
 
-use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 /// Edge runtime configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -61,11 +61,21 @@ pub struct EdgeConfig {
     pub hnsw_ef: usize,
 }
 
-fn default_max_vectors() -> usize { 10000 }
-fn default_quant_bits() -> u8 { 8 }
-fn default_true() -> bool { true }
-fn default_m() -> usize { 8 }
-fn default_ef() -> usize { 64 }
+fn default_max_vectors() -> usize {
+    10000
+}
+fn default_quant_bits() -> u8 {
+    8
+}
+fn default_true() -> bool {
+    true
+}
+fn default_m() -> usize {
+    8
+}
+fn default_ef() -> usize {
+    64
+}
 
 impl Default for EdgeConfig {
     fn default() -> Self {
@@ -143,8 +153,8 @@ struct CompactVector {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 enum VectorData {
     Full(Vec<f32>),
-    Quantized8(Vec<u8>, f32, f32),  // data, min, scale
-    Quantized4(Vec<u8>, f32, f32),  // data (packed), min, scale
+    Quantized8(Vec<u8>, f32, f32), // data, min, scale
+    Quantized4(Vec<u8>, f32, f32), // data (packed), min, scale
 }
 
 impl VectorData {
@@ -153,10 +163,8 @@ impl VectorData {
         match self {
             VectorData::Full(v) => v.clone(),
             VectorData::Quantized8(data, min, scale) => {
-                data.iter()
-                    .map(|&b| min + (b as f32) * scale)
-                    .collect()
-            }
+                data.iter().map(|&b| min + (b as f32) * scale).collect()
+            },
             VectorData::Quantized4(data, min, scale) => {
                 let mut result = Vec::with_capacity(dimension);
                 for byte in data {
@@ -168,7 +176,7 @@ impl VectorData {
                     }
                 }
                 result
-            }
+            },
         }
     }
 
@@ -225,9 +233,7 @@ impl EdgeVectorStore {
             VectorData::Full(vector)
         };
 
-        let metadata_bytes = metadata.map(|m| {
-            serde_json::to_vec(&m).unwrap_or_default()
-        });
+        let metadata_bytes = metadata.map(|m| serde_json::to_vec(&m).unwrap_or_default());
 
         let index = self.vectors.len();
         self.vectors.push(CompactVector {
@@ -249,11 +255,12 @@ impl EdgeVectorStore {
         match self.config.quantization_bits {
             8 => {
                 let scale = if range > 0.0 { range / 255.0 } else { 1.0 };
-                let data: Vec<u8> = vector.iter()
+                let data: Vec<u8> = vector
+                    .iter()
                     .map(|&v| ((v - min) / scale).round() as u8)
                     .collect();
                 VectorData::Quantized8(data, min, scale)
-            }
+            },
             4 => {
                 let scale = if range > 0.0 { range / 15.0 } else { 1.0 };
                 let mut data = Vec::with_capacity(vector.len().div_ceil(2));
@@ -267,7 +274,7 @@ impl EdgeVectorStore {
                     data.push(lo | (hi << 4));
                 }
                 VectorData::Quantized4(data, min, scale)
-            }
+            },
             _ => VectorData::Full(vector.to_vec()),
         }
     }
@@ -281,14 +288,17 @@ impl EdgeVectorStore {
             });
         }
 
-        let mut results: Vec<EdgeSearchResult> = self.vectors.iter()
+        let mut results: Vec<EdgeSearchResult> = self
+            .vectors
+            .iter()
             .map(|v| {
                 let vec = v.data.to_f32(self.dimension);
                 let score = Self::cosine_similarity(query, &vec);
 
-                let metadata = v.metadata.as_ref().and_then(|bytes| {
-                    serde_json::from_slice(bytes).ok()
-                });
+                let metadata = v
+                    .metadata
+                    .as_ref()
+                    .and_then(|bytes| serde_json::from_slice(bytes).ok());
 
                 EdgeSearchResult {
                     id: v.id.clone(),
@@ -308,9 +318,10 @@ impl EdgeVectorStore {
     pub fn get(&self, id: &str) -> Option<EdgeSearchResult> {
         self.id_to_index.get(id).map(|&idx| {
             let v = &self.vectors[idx];
-            let metadata = v.metadata.as_ref().and_then(|bytes| {
-                serde_json::from_slice(bytes).ok()
-            });
+            let metadata = v
+                .metadata
+                .as_ref()
+                .and_then(|bytes| serde_json::from_slice(bytes).ok());
 
             EdgeSearchResult {
                 id: v.id.clone(),
@@ -346,18 +357,17 @@ impl EdgeVectorStore {
             vectors: self.vectors.clone(),
         };
 
-        bincode::serialize(&state).map_err(|e| {
-            VecStoreError::Serialization(e.to_string())
-        })
+        bincode::serialize(&state).map_err(|e| VecStoreError::Serialization(e.to_string()))
     }
 
     /// Load from bytes
     pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
-        let state: EdgeState = bincode::deserialize(bytes).map_err(|e| {
-            VecStoreError::Serialization(e.to_string())
-        })?;
+        let state: EdgeState =
+            bincode::deserialize(bytes).map_err(|e| VecStoreError::Serialization(e.to_string()))?;
 
-        let id_to_index: HashMap<String, usize> = state.vectors.iter()
+        let id_to_index: HashMap<String, usize> = state
+            .vectors
+            .iter()
             .enumerate()
             .map(|(i, v)| (v.id.clone(), i))
             .collect();
@@ -405,18 +415,16 @@ impl EdgeVectorStore {
 
     /// Get memory usage estimate
     pub fn memory_usage(&self) -> MemoryUsage {
-        let vector_bytes: usize = self.vectors.iter()
-            .map(|v| v.data.memory_size())
-            .sum();
+        let vector_bytes: usize = self.vectors.iter().map(|v| v.data.memory_size()).sum();
 
-        let metadata_bytes: usize = self.vectors.iter()
+        let metadata_bytes: usize = self
+            .vectors
+            .iter()
             .filter_map(|v| v.metadata.as_ref())
             .map(|m| m.len())
             .sum();
 
-        let id_bytes: usize = self.vectors.iter()
-            .map(|v| v.id.len())
-            .sum();
+        let id_bytes: usize = self.vectors.iter().map(|v| v.id.len()).sum();
 
         MemoryUsage {
             vector_bytes,
@@ -475,17 +483,19 @@ pub mod wasm {
 
         #[wasm_bindgen]
         pub fn add(&mut self, id: &str, vector: &[f32]) -> Result<(), JsValue> {
-            self.inner.add(id, vector.to_vec(), None)
+            self.inner
+                .add(id, vector.to_vec(), None)
                 .map_err(|e| JsValue::from_str(&e.to_string()))
         }
 
         #[wasm_bindgen]
         pub fn search(&self, query: &[f32], k: usize) -> Result<JsValue, JsValue> {
-            let results = self.inner.search(query, k)
+            let results = self
+                .inner
+                .search(query, k)
                 .map_err(|e| JsValue::from_str(&e.to_string()))?;
 
-            serde_wasm_bindgen::to_value(&results)
-                .map_err(|e| JsValue::from_str(&e.to_string()))
+            serde_wasm_bindgen::to_value(&results).map_err(|e| JsValue::from_str(&e.to_string()))
         }
 
         #[wasm_bindgen]
diff --git a/src/embedded_onnx.rs b/src/embedded_onnx.rs
index 6dab593..f401263 100644
--- a/src/embedded_onnx.rs
+++ b/src/embedded_onnx.rs
@@ -30,13 +30,13 @@
 //! let results = store.search_text("greeting", 10)?;
 //! ```
 
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::sync::RwLock;
 #[cfg(feature = "embeddings")]
 use std::sync::Arc;
-use serde::{Deserialize, Serialize};
+use std::sync::RwLock;
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 // ============================================================================
 // MODEL CONFIGURATION
@@ -115,7 +115,9 @@ impl ModelType {
     /// Get the default query prefix for this model
     pub fn default_query_prefix(&self) -> Option<&str> {
         match self {
-            ModelType::BgeSmallEnV15 | ModelType::BgeBaseEnV15 => Some("Represent this sentence for searching relevant passages: "),
+            ModelType::BgeSmallEnV15 | ModelType::BgeBaseEnV15 => {
+                Some("Represent this sentence for searching relevant passages: ")
+            },
             ModelType::E5SmallV2 | ModelType::E5BaseV2 => Some("query: "),
             _ => None,
         }
@@ -301,8 +303,6 @@ impl EmbeddingModel {
 
     /// Load with configuration
     pub fn with_config(config: ModelConfig) -> Result<Self> {
-        
-
         let dimension = config.model_type.dimension();
 
         // Get model directory
@@ -393,11 +393,11 @@ impl EmbeddingModel {
 
         // Set optimization level based on quantization
         if config.quantize {
-            session_builder = session_builder
-                .with_optimization_level(GraphOptimizationLevel::Level3)?;
+            session_builder =
+                session_builder.with_optimization_level(GraphOptimizationLevel::Level3)?;
         } else {
-            session_builder = session_builder
-                .with_optimization_level(GraphOptimizationLevel::Level2)?;
+            session_builder =
+                session_builder.with_optimization_level(GraphOptimizationLevel::Level2)?;
         }
 
         // Set number of threads
@@ -406,9 +406,8 @@ impl EmbeddingModel {
         // Add execution providers
         #[cfg(feature = "cuda")]
         if config.use_gpu {
-            session_builder = session_builder.with_execution_providers([
-                ort::CUDAExecutionProvider::default().build(),
-            ])?;
+            session_builder = session_builder
+                .with_execution_providers([ort::CUDAExecutionProvider::default().build()])?;
         }
 
         // Load model
@@ -427,19 +426,13 @@ impl EmbeddingModel {
         let cache_dir = home.home_dir().join(".vecstore").join("models");
         let model_dir = cache_dir.join(model_type.huggingface_id().replace('/', "_"));
 
-        std::fs::create_dir_all(&model_dir)
-            .map_err(|e| VecStoreError::Io(e))?;
+        std::fs::create_dir_all(&model_dir).map_err(|e| VecStoreError::Io(e))?;
 
         Ok(model_dir)
     }
 
     /// Download model files from HuggingFace
-    fn download_model(
-        model_type: &ModelType,
-        model_dir: &std::path::Path,
-    ) -> Result<()> {
-        
-
+    fn download_model(model_type: &ModelType, model_dir: &std::path::Path) -> Result<()> {
         let base_url = format!(
             "https://huggingface.co/{}/resolve/main",
             model_type.huggingface_id()
@@ -457,16 +450,14 @@ impl EmbeddingModel {
 
             tracing::info!("Downloading {}...", remote_name);
 
-            let response = ureq::get(&url)
-                .call()
-                .map_err(|e| VecStoreError::Internal(format!("Failed to download {}: {}", url, e)))?;
+            let response = ureq::get(&url).call().map_err(|e| {
+                VecStoreError::Internal(format!("Failed to download {}: {}", url, e))
+            })?;
 
             let mut reader = response.into_body().into_reader();
-            let mut file = std::fs::File::create(&dest)
-                .map_err(|e| VecStoreError::Io(e))?;
+            let mut file = std::fs::File::create(&dest).map_err(|e| VecStoreError::Io(e))?;
 
-            std::io::copy(&mut reader, &mut file)
-                .map_err(|e| VecStoreError::Io(e))?;
+            std::io::copy(&mut reader, &mut file).map_err(|e| VecStoreError::Io(e))?;
 
             tracing::info!("Downloaded {} successfully", remote_name);
         }
@@ -499,7 +490,9 @@ impl EmbeddingModel {
     /// Embed a single text
     pub fn embed(&self, text: &str) -> Result<Vec<f32>> {
         let embeddings = self.embed_batch(&[text.to_string()])?;
-        embeddings.into_iter().next()
+        embeddings
+            .into_iter()
+            .next()
             .ok_or_else(|| VecStoreError::InvalidInput("No embedding returned".to_string()))
     }
 
@@ -607,16 +600,20 @@ impl EmbeddingModel {
             .map_err(|e| VecStoreError::Internal(format!("Array shape error: {}", e)))?;
 
         // Create ONNX input tensors using ort 2.0 API
-        let input_ids_tensor = Tensor::from_array(input_ids_array)
-            .map_err(|e| VecStoreError::OnnxRuntime(format!("Failed to create input_ids tensor: {}", e)))?;
-        let attention_mask_tensor = Tensor::from_array(attention_mask_array)
-            .map_err(|e| VecStoreError::OnnxRuntime(format!("Failed to create attention_mask tensor: {}", e)))?;
-        let token_type_ids_tensor = Tensor::from_array(token_type_ids_array)
-            .map_err(|e| VecStoreError::OnnxRuntime(format!("Failed to create token_type_ids tensor: {}", e)))?;
+        let input_ids_tensor = Tensor::from_array(input_ids_array).map_err(|e| {
+            VecStoreError::OnnxRuntime(format!("Failed to create input_ids tensor: {}", e))
+        })?;
+        let attention_mask_tensor = Tensor::from_array(attention_mask_array).map_err(|e| {
+            VecStoreError::OnnxRuntime(format!("Failed to create attention_mask tensor: {}", e))
+        })?;
+        let token_type_ids_tensor = Tensor::from_array(token_type_ids_array).map_err(|e| {
+            VecStoreError::OnnxRuntime(format!("Failed to create token_type_ids tensor: {}", e))
+        })?;
 
         // Get mutable access to session for inference
-        let mut session = self.session.write()
-            .map_err(|e| VecStoreError::LockError(format!("Failed to acquire session lock: {}", e)))?;
+        let mut session = self.session.write().map_err(|e| {
+            VecStoreError::LockError(format!("Failed to acquire session lock: {}", e))
+        })?;
 
         // Run inference using ort::inputs! macro
         let outputs = session
@@ -642,13 +639,15 @@ impl EmbeddingModel {
             ndarray::ArrayD::from_shape_vec(
                 shape.to_vec(),
                 embeddings_view.iter().copied().collect(),
-            ).map_err(|e| VecStoreError::Internal(format!("Array conversion error: {}", e)))?
+            )
+            .map_err(|e| VecStoreError::Internal(format!("Array conversion error: {}", e)))?
         } else if shape.len() == 2 {
             // Shape is (batch_size, hidden_size) - already pooled by model
             ndarray::ArrayD::from_shape_vec(
                 shape.to_vec(),
                 embeddings_view.iter().copied().collect(),
-            ).map_err(|e| VecStoreError::Internal(format!("Array conversion error: {}", e)))?
+            )
+            .map_err(|e| VecStoreError::Internal(format!("Array conversion error: {}", e)))?
         } else {
             return Err(VecStoreError::OnnxRuntime(format!(
                 "Unexpected output shape: {:?}",
@@ -751,7 +750,11 @@ impl EmbeddingModel {
 
     /// Get statistics
     pub fn stats(&self) -> ModelStats {
-        self.stats.read().ok().map(|g| g.clone()).unwrap_or_default()
+        self.stats
+            .read()
+            .ok()
+            .map(|g| g.clone())
+            .unwrap_or_default()
     }
 }
 
@@ -789,15 +792,64 @@ impl EmbeddingModel {
     fn build_simple_vocab() -> HashMap<String, usize> {
         // Fallback vocabulary - enable `embeddings` feature for real BPE/WordPiece tokenization
         let words = [
-            "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
-            "have", "has", "had", "do", "does", "did", "will", "would", "could",
-            "should", "may", "might", "must", "can", "this", "that", "these",
-            "those", "i", "you", "he", "she", "it", "we", "they", "what", "which",
-            "who", "whom", "where", "when", "why", "how", "hello", "world", "test",
-            "document", "search", "query", "vector", "embedding", "model", "text",
+            "the",
+            "a",
+            "an",
+            "is",
+            "are",
+            "was",
+            "were",
+            "be",
+            "been",
+            "being",
+            "have",
+            "has",
+            "had",
+            "do",
+            "does",
+            "did",
+            "will",
+            "would",
+            "could",
+            "should",
+            "may",
+            "might",
+            "must",
+            "can",
+            "this",
+            "that",
+            "these",
+            "those",
+            "i",
+            "you",
+            "he",
+            "she",
+            "it",
+            "we",
+            "they",
+            "what",
+            "which",
+            "who",
+            "whom",
+            "where",
+            "when",
+            "why",
+            "how",
+            "hello",
+            "world",
+            "test",
+            "document",
+            "search",
+            "query",
+            "vector",
+            "embedding",
+            "model",
+            "text",
         ];
 
-        words.iter().enumerate()
+        words
+            .iter()
+            .enumerate()
             .map(|(i, &w)| (w.to_string(), i))
             .collect()
     }
@@ -810,7 +862,9 @@ impl EmbeddingModel {
     /// Embed a single text
     pub fn embed(&self, text: &str) -> Result<Vec<f32>> {
         let embeddings = self.embed_batch(&[text.to_string()])?;
-        embeddings.into_iter().next()
+        embeddings
+            .into_iter()
+            .next()
             .ok_or_else(|| VecStoreError::InvalidInput("No embedding returned".to_string()))
     }
 
@@ -818,9 +872,7 @@ impl EmbeddingModel {
     pub fn embed_batch(&self, texts: &[String]) -> Result<Vec<Vec<f32>>> {
         let start = std::time::Instant::now();
 
-        let embeddings: Vec<Vec<f32>> = texts.iter()
-            .map(|text| self.embed_text(text))
-            .collect();
+        let embeddings: Vec<Vec<f32>> = texts.iter().map(|text| self.embed_text(text)).collect();
 
         // Update stats
         {
@@ -870,12 +922,11 @@ impl EmbeddingModel {
             .split_whitespace()
             .map(|word| {
                 // Clean word
-                let clean: String = word.chars()
-                    .filter(|c| c.is_alphanumeric())
-                    .collect();
+                let clean: String = word.chars().filter(|c| c.is_alphanumeric()).collect();
 
                 // Look up in vocabulary or use hash
-                self.vocab.get(&clean)
+                self.vocab
+                    .get(&clean)
                     .copied()
                     .unwrap_or_else(|| self.hash_word(&clean))
             })
@@ -894,7 +945,9 @@ impl EmbeddingModel {
 
     /// Get statistics
     pub fn stats(&self) -> ModelStats {
-        let Ok(guard) = self.stats.read() else { return ModelStats::default(); };
+        let Ok(guard) = self.stats.read() else {
+            return ModelStats::default();
+        };
         guard.clone()
     }
 }
@@ -980,7 +1033,7 @@ impl EmbeddedStore {
                     stats.cache_hits += 1;
                 }
                 e
-            }
+            },
             None => {
                 #[cfg(feature = "embeddings")]
                 let e = self.model.embed_document(text)?;
@@ -997,7 +1050,7 @@ impl EmbeddedStore {
                 }
 
                 e
-            }
+            },
         };
 
         // Store vector
@@ -1086,7 +1139,9 @@ impl EmbeddedStore {
 
     /// Delete by ID
     pub fn delete(&self, id: &str) -> bool {
-        let Ok(mut vectors) = self.vectors.write() else { return false; };
+        let Ok(mut vectors) = self.vectors.write() else {
+            return false;
+        };
         let removed = vectors.remove(id).is_some();
         drop(vectors);
 
@@ -1123,7 +1178,8 @@ impl EmbeddedStore {
         let texts = self.texts.read()?;
         let metadata = self.metadata.read()?;
 
-        let mut results: Vec<_> = vectors.iter()
+        let mut results: Vec<_> = vectors
+            .iter()
             .map(|(id, vec)| {
                 let score = cosine_similarity(query, vec);
                 SearchResult {
@@ -1143,7 +1199,9 @@ impl EmbeddedStore {
 
     /// Get by ID
     pub fn get(&self, id: &str) -> Option<(Vec<f32>, Option<String>, Option<serde_json::Value>)> {
-        let Ok(vectors) = self.vectors.read() else { return None; };
+        let Ok(vectors) = self.vectors.read() else {
+            return None;
+        };
         vectors.get(id).map(|v| {
             let text = self.texts.read().ok().and_then(|t| t.get(id).cloned());
             let meta = self.metadata.read().ok().and_then(|m| m.get(id).cloned());
@@ -1158,13 +1216,17 @@ impl EmbeddedStore {
 
     /// Get count
     pub fn len(&self) -> usize {
-        let Ok(guard) = self.vectors.read() else { return 0; };
+        let Ok(guard) = self.vectors.read() else {
+            return 0;
+        };
         guard.len()
     }
 
     /// Check if empty
     pub fn is_empty(&self) -> bool {
-        let Ok(guard) = self.vectors.read() else { return true; };
+        let Ok(guard) = self.vectors.read() else {
+            return true;
+        };
         guard.is_empty()
     }
 
@@ -1230,7 +1292,9 @@ pub trait EmbeddingFunction: Send + Sync {
     /// Embed a single text
     fn embed_one(&self, text: &str) -> Result<Vec<f32>> {
         let embeddings = self.embed(&[text.to_string()])?;
-        embeddings.into_iter().next()
+        embeddings
+            .into_iter()
+            .next()
             .ok_or_else(|| VecStoreError::InvalidInput("No embedding returned".to_string()))
     }
 
diff --git a/src/embedding_vcs.rs b/src/embedding_vcs.rs
index a01ba91..567adad 100644
--- a/src/embedding_vcs.rs
+++ b/src/embedding_vcs.rs
@@ -40,7 +40,7 @@
 //! vcs.checkout(&commit_id)?;
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
@@ -430,7 +430,10 @@ impl EmbeddingVCS {
         use std::hash::{Hash, Hasher};
         let mut hasher = std::collections::hash_map::DefaultHasher::new();
         message.hash(&mut hasher);
-        chrono::Utc::now().timestamp_nanos_opt().unwrap_or(0).hash(&mut hasher);
+        chrono::Utc::now()
+            .timestamp_nanos_opt()
+            .unwrap_or(0)
+            .hash(&mut hasher);
         format!("{:016x}", hasher.finish())
     }
 
diff --git a/src/embeddings.rs b/src/embeddings.rs
index 995521a..1d4e2d8 100644
--- a/src/embeddings.rs
+++ b/src/embeddings.rs
@@ -47,12 +47,12 @@ pub use candle_backend::{CandleEmbedder, CandleModel};
 use anyhow::Result;
 
 #[cfg(feature = "embeddings")]
-use anyhow::{anyhow, Context};
+use anyhow::{Context, anyhow};
 
 #[cfg(feature = "embeddings")]
 use ndarray::Array2;
 #[cfg(feature = "embeddings")]
-use ort::session::{builder::GraphOptimizationLevel, Session};
+use ort::session::{Session, builder::GraphOptimizationLevel};
 #[cfg(feature = "embeddings")]
 use std::path::{Path, PathBuf};
 #[cfg(feature = "embeddings")]
@@ -315,7 +315,9 @@ impl Embedder {
         // Run inference using ort 2.0 inputs! macro and extract results
         // We need to extract data while holding the lock, then release it
         let embeddings_array = {
-            let mut session_guard = self.session.lock()
+            let mut session_guard = self
+                .session
+                .lock()
                 .map_err(|e| anyhow!("Failed to lock session: {}", e))?;
             let outputs = session_guard
                 .run(ort::inputs![
diff --git a/src/embeddings/additional_providers.rs b/src/embeddings/additional_providers.rs
index dfa8c8e..745e016 100644
--- a/src/embeddings/additional_providers.rs
+++ b/src/embeddings/additional_providers.rs
@@ -3,7 +3,7 @@
 // Azure OpenAI, HuggingFace Inference API, Jina AI
 
 use super::TextEmbedder;
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 
@@ -136,13 +136,13 @@ impl AzureEmbedding {
                     data.sort_by_key(|d| d.index);
 
                     return Ok(data.into_iter().map(|d| d.embedding).collect());
-                }
+                },
                 Ok(resp) if resp.status().as_u16() == 429 && retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Ok(resp) => {
                     let status = resp.status();
                     let body = resp
@@ -150,16 +150,16 @@ impl AzureEmbedding {
                         .await
                         .unwrap_or_else(|_| String::from("(no body)"));
                     return Err(anyhow!("Azure API error {}: {}", status, body));
-                }
+                },
                 Err(_e) if retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Err(e) => {
                     return Err(anyhow!("Failed to call Azure API: {}", e));
-                }
+                },
             }
         }
     }
@@ -273,19 +273,19 @@ impl HuggingFaceEmbedding {
                         .context("Failed to parse HuggingFace response")?;
 
                     return Ok(embeddings);
-                }
+                },
                 Ok(resp) if resp.status().as_u16() == 429 && retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Ok(resp) if resp.status().as_u16() == 503 && retries < self.max_retries => {
                     // Model loading, retry after longer wait
                     retries += 1;
                     tokio::time::sleep(Duration::from_secs(10)).await;
                     continue;
-                }
+                },
                 Ok(resp) => {
                     let status = resp.status();
                     let body = resp
@@ -293,16 +293,16 @@ impl HuggingFaceEmbedding {
                         .await
                         .unwrap_or_else(|_| String::from("(no body)"));
                     return Err(anyhow!("HuggingFace API error {}: {}", status, body));
-                }
+                },
                 Err(_e) if retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Err(e) => {
                     return Err(anyhow!("Failed to call HuggingFace API: {}", e));
-                }
+                },
             }
         }
     }
@@ -442,13 +442,13 @@ impl JinaEmbedding {
                     data.sort_by_key(|d| d.index);
 
                     return Ok(data.into_iter().map(|d| d.embedding).collect());
-                }
+                },
                 Ok(resp) if resp.status().as_u16() == 429 && retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Ok(resp) => {
                     let status = resp.status();
                     let body = resp
@@ -456,16 +456,16 @@ impl JinaEmbedding {
                         .await
                         .unwrap_or_else(|_| String::from("(no body)"));
                     return Err(anyhow!("Jina API error {}: {}", status, body));
-                }
+                },
                 Err(_e) if retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Err(e) => {
                     return Err(anyhow!("Failed to call Jina API: {}", e));
-                }
+                },
             }
         }
     }
diff --git a/src/embeddings/candle_backend.rs b/src/embeddings/candle_backend.rs
index 468fddb..af6594b 100644
--- a/src/embeddings/candle_backend.rs
+++ b/src/embeddings/candle_backend.rs
@@ -4,11 +4,11 @@
 //! enabling fully native Rust embeddings without Python dependencies.
 
 use crate::embeddings::TextEmbedder;
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result, anyhow};
 use candle_core::{Device, Tensor};
 use candle_nn::VarBuilder;
 use candle_transformers::models::bert::{BertModel, Config, DTYPE};
-use hf_hub::{api::sync::Api, Repo, RepoType};
+use hf_hub::{Repo, RepoType, api::sync::Api};
 use tokenizers::Tokenizer;
 
 /// Supported Candle embedding models
@@ -225,7 +225,11 @@ impl TextEmbedder for CandleEmbedder {
             .collect::<Result<Vec<_>>>()?;
 
         // Find max sequence length for padding
-        let max_len = encodings.iter().map(|e| e.get_ids().len()).max().unwrap_or(0);
+        let max_len = encodings
+            .iter()
+            .map(|e| e.get_ids().len())
+            .max()
+            .unwrap_or(0);
 
         // Pad sequences and create batch tensors
         let batch_size = encodings.len();
diff --git a/src/embeddings/cloud_providers.rs b/src/embeddings/cloud_providers.rs
index 40bf7de..7e6fb8e 100644
--- a/src/embeddings/cloud_providers.rs
+++ b/src/embeddings/cloud_providers.rs
@@ -13,7 +13,7 @@
 // Each provider implements the TextEmbedder trait for seamless integration.
 
 use super::TextEmbedder;
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use std::time::Duration;
@@ -82,7 +82,9 @@ impl RateLimiter {
     }
 
     async fn wait_if_needed(&self) {
-        let Ok(mut requests) = self.last_requests.lock() else { return; };
+        let Ok(mut requests) = self.last_requests.lock() else {
+            return;
+        };
 
         // Remove requests older than 1 minute
         let now = std::time::Instant::now();
@@ -98,7 +100,9 @@ impl RateLimiter {
                 if wait_time > Duration::from_secs(0) {
                     drop(requests); // Release lock before sleeping
                     tokio::time::sleep(wait_time).await;
-                    let Ok(reacquired) = self.last_requests.lock() else { return; };
+                    let Ok(reacquired) = self.last_requests.lock() else {
+                        return;
+                    };
                     requests = reacquired;
                 }
             }
@@ -214,13 +218,13 @@ impl CohereEmbedding {
                         .context("Failed to parse Cohere response")?;
 
                     return Ok(embed_response.embeddings);
-                }
+                },
                 Ok(resp) if resp.status().as_u16() == 429 && retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Ok(resp) => {
                     let status = resp.status();
                     let body = resp
@@ -228,16 +232,16 @@ impl CohereEmbedding {
                         .await
                         .unwrap_or_else(|_| String::from("(no body)"));
                     return Err(anyhow!("Cohere API error {}: {}", status, body));
-                }
+                },
                 Err(_e) if retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Err(e) => {
                     return Err(anyhow!("Failed to call Cohere API: {}", e));
-                }
+                },
             }
         }
     }
@@ -428,13 +432,13 @@ impl VoyageEmbedding {
                     data.sort_by_key(|d| d.index);
 
                     return Ok(data.into_iter().map(|d| d.embedding).collect());
-                }
+                },
                 Ok(resp) if resp.status().as_u16() == 429 && retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Ok(resp) => {
                     let status = resp.status();
                     let body = resp
@@ -442,16 +446,16 @@ impl VoyageEmbedding {
                         .await
                         .unwrap_or_else(|_| String::from("(no body)"));
                     return Err(anyhow!("Voyage API error {}: {}", status, body));
-                }
+                },
                 Err(_e) if retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Err(e) => {
                     return Err(anyhow!("Failed to call Voyage API: {}", e));
-                }
+                },
             }
         }
     }
@@ -630,13 +634,13 @@ impl MistralEmbedding {
                     data.sort_by_key(|d| d.index);
 
                     return Ok(data.into_iter().map(|d| d.embedding).collect());
-                }
+                },
                 Ok(resp) if resp.status().as_u16() == 429 && retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Ok(resp) => {
                     let status = resp.status();
                     let body = resp
@@ -644,16 +648,16 @@ impl MistralEmbedding {
                         .await
                         .unwrap_or_else(|_| String::from("(no body)"));
                     return Err(anyhow!("Mistral API error {}: {}", status, body));
-                }
+                },
                 Err(_e) if retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Err(e) => {
                     return Err(anyhow!("Failed to call Mistral API: {}", e));
-                }
+                },
             }
         }
     }
@@ -701,7 +705,7 @@ impl GoogleModel {
             GoogleModel::TextEmbedding004 => "text-embedding-004",
             GoogleModel::TextEmbeddingGeckoMultilingual => {
                 "textembedding-gecko-multilingual@latest"
-            }
+            },
         }
     }
 
@@ -794,7 +798,10 @@ impl GoogleEmbedding {
 
         let url = format!(
             "https://{}-aiplatform.googleapis.com/v1/projects/{}/locations/{}/publishers/google/models/{}:predict",
-            self.location, self.project_id, self.location, self.model.as_str()
+            self.location,
+            self.project_id,
+            self.location,
+            self.model.as_str()
         );
 
         let mut retries = 0;
@@ -820,13 +827,13 @@ impl GoogleEmbedding {
                         .into_iter()
                         .map(|p| p.embeddings.values)
                         .collect());
-                }
+                },
                 Ok(resp) if resp.status().as_u16() == 429 && retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Ok(resp) => {
                     let status = resp.status();
                     let body = resp
@@ -834,16 +841,16 @@ impl GoogleEmbedding {
                         .await
                         .unwrap_or_else(|_| String::from("(no body)"));
                     return Err(anyhow!("Google API error {}: {}", status, body));
-                }
+                },
                 Err(_e) if retries < self.max_retries => {
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Err(e) => {
                     return Err(anyhow!("Failed to call Google API: {}", e));
-                }
+                },
             }
         }
     }
diff --git a/src/embeddings/ollama_backend.rs b/src/embeddings/ollama_backend.rs
index 31a2387..9dd7461 100644
--- a/src/embeddings/ollama_backend.rs
+++ b/src/embeddings/ollama_backend.rs
@@ -10,7 +10,7 @@
 //! - Any Ollama embedding model
 
 use super::TextEmbedder;
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 
diff --git a/src/embeddings/openai_backend.rs b/src/embeddings/openai_backend.rs
index 2bfa4c2..34fa1a5 100644
--- a/src/embeddings/openai_backend.rs
+++ b/src/embeddings/openai_backend.rs
@@ -4,7 +4,7 @@
 // Supports text-embedding-3-small, text-embedding-3-large, and ada-002 models.
 
 use super::TextEmbedder;
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use std::time::Duration;
@@ -92,7 +92,9 @@ impl RateLimiter {
     }
 
     async fn wait_if_needed(&self) {
-        let Ok(mut requests) = self.last_requests.lock() else { return; };
+        let Ok(mut requests) = self.last_requests.lock() else {
+            return;
+        };
 
         // Remove requests older than 1 minute
         let now = std::time::Instant::now();
@@ -108,7 +110,9 @@ impl RateLimiter {
                 if wait_time > Duration::from_secs(0) {
                     drop(requests); // Release lock before sleeping
                     tokio::time::sleep(wait_time).await;
-                    let Ok(reacquired) = self.last_requests.lock() else { return; };
+                    let Ok(reacquired) = self.last_requests.lock() else {
+                        return;
+                    };
                     requests = reacquired;
                 }
             }
@@ -312,14 +316,14 @@ impl OpenAIEmbedding {
                     data.sort_by_key(|d| d.index);
 
                     return Ok(data.into_iter().map(|d| d.embedding).collect());
-                }
+                },
                 Ok(resp) if resp.status().as_u16() == 429 && retries < self.max_retries => {
                     // Rate limit hit, retry with exponential backoff
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Ok(resp) => {
                     let status = resp.status();
                     let body = resp
@@ -327,17 +331,17 @@ impl OpenAIEmbedding {
                         .await
                         .unwrap_or_else(|_| String::from("(no body)"));
                     return Err(anyhow!("OpenAI API error {}: {}", status, body));
-                }
+                },
                 Err(_e) if retries < self.max_retries => {
                     // Network error, retry
                     retries += 1;
                     let wait_time = Duration::from_secs(2_u64.pow(retries as u32));
                     tokio::time::sleep(wait_time).await;
                     continue;
-                }
+                },
                 Err(e) => {
                     return Err(anyhow!("Failed to call OpenAI API: {}", e));
-                }
+                },
             }
         }
     }
diff --git a/src/enterprise_protect.rs b/src/enterprise_protect.rs
index 0cadd2f..5431254 100644
--- a/src/enterprise_protect.rs
+++ b/src/enterprise_protect.rs
@@ -46,29 +46,15 @@ use crate::error::{Result, VecStoreError};
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum KMSProvider {
     /// AWS Key Management Service
-    AWSKMS {
-        key_arn: String,
-        region: String,
-    },
+    AWSKMS { key_arn: String, region: String },
     /// Google Cloud KMS
-    GCPKMS {
-        key_name: String,
-        project: String,
-    },
+    GCPKMS { key_name: String, project: String },
     /// Azure Key Vault
-    AzureKeyVault {
-        vault_url: String,
-        key_name: String,
-    },
+    AzureKeyVault { vault_url: String, key_name: String },
     /// HashiCorp Vault
-    HashiCorpVault {
-        address: String,
-        path: String,
-    },
+    HashiCorpVault { address: String, path: String },
     /// Local key (for development/testing)
-    Local {
-        key_path: PathBuf,
-    },
+    Local { key_path: PathBuf },
 }
 
 /// CMEK configuration
@@ -178,7 +164,9 @@ impl EncryptionManager {
     pub fn initialize(&self) -> Result<()> {
         let dek = self.generate_dek()?;
 
-        let mut current = self.current_dek.write()
+        let mut current = self
+            .current_dek
+            .write()
             .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
         *current = Some(dek);
 
@@ -200,7 +188,7 @@ impl EncryptionManager {
             ciphertext,
             key_id: dek.key_id.clone(),
             algorithm: "XOR".to_string(), // Use "AES-256-GCM" in production
-            nonce: vec![0u8; 12], // Would be random in production
+            nonce: vec![0u8; 12],         // Would be random in production
         })
     }
 
@@ -209,7 +197,8 @@ impl EncryptionManager {
         let dek = self.get_dek(&encrypted.key_id)?;
 
         // Simple XOR decryption
-        let plaintext: Vec<u8> = encrypted.ciphertext
+        let plaintext: Vec<u8> = encrypted
+            .ciphertext
             .iter()
             .enumerate()
             .map(|(i, &b)| b ^ dek.key[i % dek.key.len()])
@@ -220,21 +209,27 @@ impl EncryptionManager {
 
     /// Rotate encryption key
     pub fn rotate_key(&self) -> Result<KeyRotationResult> {
-        let old_dek = self.current_dek.read()
+        let old_dek = self
+            .current_dek
+            .read()
             .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
             .clone();
         let new_dek = self.generate_dek()?;
 
         // Store old key in cache for decryption
         if let Some(ref old) = old_dek {
-            let mut cache = self.dek_cache.write()
+            let mut cache = self
+                .dek_cache
+                .write()
                 .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
             cache.insert(old.key_id.clone(), old.clone());
         }
 
         // Set new key as current
         {
-            let mut current = self.current_dek.write()
+            let mut current = self
+                .current_dek
+                .write()
                 .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
             *current = Some(new_dek.clone());
         }
@@ -249,7 +244,9 @@ impl EncryptionManager {
     fn generate_dek(&self) -> Result<DataEncryptionKey> {
         // In production, this would call the KMS to generate a DEK
         let counter = self.key_counter.fetch_add(1, Ordering::Relaxed);
-        let key: Vec<u8> = (0..32).map(|i| ((i * 7 + 13 + counter as usize) % 256) as u8).collect();
+        let key: Vec<u8> = (0..32)
+            .map(|i| ((i * 7 + 13 + counter as usize) % 256) as u8)
+            .collect();
         let key_id = format!("dek_{}_{}", unix_timestamp(), counter);
 
         Ok(DataEncryptionKey {
@@ -266,26 +263,35 @@ impl EncryptionManager {
     }
 
     fn get_current_dek(&self) -> Result<DataEncryptionKey> {
-        let dek = self.current_dek.read()
+        let dek = self
+            .current_dek
+            .read()
             .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
-        dek.clone().ok_or_else(|| VecStoreError::EncryptionError("DEK not initialized".to_string()))
+        dek.clone()
+            .ok_or_else(|| VecStoreError::EncryptionError("DEK not initialized".to_string()))
     }
 
     fn get_dek(&self, key_id: &str) -> Result<DataEncryptionKey> {
         // Check current key
         {
-            let current = self.current_dek.read()
+            let current = self
+                .current_dek
+                .read()
                 .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
             if let Some(dek) = &*current
-                && dek.key_id == key_id {
-                    return Ok(dek.clone());
-                }
+                && dek.key_id == key_id
+            {
+                return Ok(dek.clone());
+            }
         }
 
         // Check cache
-        let cache = self.dek_cache.read()
+        let cache = self
+            .dek_cache
+            .read()
             .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
-        cache.get(key_id)
+        cache
+            .get(key_id)
             .cloned()
             .ok_or_else(|| VecStoreError::EncryptionError(format!("DEK not found: {}", key_id)))
     }
@@ -438,7 +444,9 @@ impl BackupManager {
 
         // Store backup metadata
         {
-            let mut backups = self.backups.write()
+            let mut backups = self
+                .backups
+                .write()
                 .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
             backups.push(metadata.clone());
 
@@ -453,11 +461,14 @@ impl BackupManager {
 
     /// List backups
     pub fn list_backups(&self, collection: Option<&str>) -> Result<Vec<BackupMetadata>> {
-        let backups = self.backups.read()
+        let backups = self
+            .backups
+            .read()
             .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
 
         if let Some(col) = collection {
-            Ok(backups.iter()
+            Ok(backups
+                .iter()
                 .filter(|b| b.collection == col)
                 .cloned()
                 .collect())
@@ -492,7 +503,9 @@ impl BackupManager {
 
     /// Delete backup
     pub fn delete_backup(&self, backup_id: &str) -> Result<bool> {
-        let mut backups = self.backups.write()
+        let mut backups = self
+            .backups
+            .write()
             .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
         let len_before = backups.len();
         backups.retain(|b| b.backup_id != backup_id);
@@ -501,7 +514,9 @@ impl BackupManager {
 
     /// Get backup statistics
     pub fn stats(&self) -> Result<BackupStats> {
-        let backups = self.backups.read()
+        let backups = self
+            .backups
+            .read()
             .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
 
         let total_size: u64 = backups.iter().map(|b| b.size_bytes).sum();
@@ -765,9 +780,21 @@ impl ComplianceChecker {
 
     /// Get compliance summary
     pub fn summary(&self) -> ComplianceSummary {
-        let passed = self.checks.iter().filter(|c| c.status == ComplianceStatus::Passed).count();
-        let failed = self.checks.iter().filter(|c| c.status == ComplianceStatus::Failed).count();
-        let warnings = self.checks.iter().filter(|c| c.status == ComplianceStatus::Warning).count();
+        let passed = self
+            .checks
+            .iter()
+            .filter(|c| c.status == ComplianceStatus::Passed)
+            .count();
+        let failed = self
+            .checks
+            .iter()
+            .filter(|c| c.status == ComplianceStatus::Failed)
+            .count();
+        let warnings = self
+            .checks
+            .iter()
+            .filter(|c| c.status == ComplianceStatus::Warning)
+            .count();
 
         ComplianceSummary {
             total_checks: self.checks.len(),
@@ -790,8 +817,7 @@ pub struct ComplianceSummary {
 }
 
 /// Enterprise configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[derive(Default)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct EnterpriseConfig {
     pub encryption_enabled: bool,
     pub audit_logging: bool,
@@ -800,7 +826,6 @@ pub struct EnterpriseConfig {
     pub retention_policy: Option<RetentionPolicy>,
 }
 
-
 fn unix_timestamp() -> i64 {
     SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -898,7 +923,10 @@ mod tests {
         let aws = CMEKConfig::aws_kms("arn:aws:kms:us-east-1:123456789:key/abc");
         assert!(matches!(aws.provider, KMSProvider::AWSKMS { .. }));
 
-        let gcp = CMEKConfig::gcp_kms("projects/my-project/locations/global/keyRings/my-ring/cryptoKeys/my-key", "my-project");
+        let gcp = CMEKConfig::gcp_kms(
+            "projects/my-project/locations/global/keyRings/my-ring/cryptoKeys/my-key",
+            "my-project",
+        );
         assert!(matches!(gcp.provider, KMSProvider::GCPKMS { .. }));
 
         let azure = CMEKConfig::azure_keyvault("https://myvault.vault.azure.net", "my-key");
diff --git a/src/explainable.rs b/src/explainable.rs
index aae3461..0c8eb74 100644
--- a/src/explainable.rs
+++ b/src/explainable.rs
@@ -41,8 +41,7 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
 /// Level of explanation detail
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-#[derive(Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Default)]
 pub enum ExplainLevel {
     /// Minimal - just the score
     Minimal,
@@ -57,7 +56,6 @@ pub enum ExplainLevel {
     Debug,
 }
 
-
 /// Dimension contribution to similarity
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DimensionContribution {
@@ -302,7 +300,7 @@ impl ExplainableSearch {
                 } else {
                     0.0
                 }
-            }
+            },
             DistanceMetric::Euclidean => {
                 let dist: f32 = a
                     .iter()
@@ -311,7 +309,7 @@ impl ExplainableSearch {
                     .sum::<f32>()
                     .sqrt();
                 1.0 / (1.0 + dist) // Convert to similarity
-            }
+            },
             DistanceMetric::DotProduct => a.iter().zip(b.iter()).map(|(x, y)| x * y).sum(),
         }
     }
@@ -355,30 +353,28 @@ impl ExplainableSearch {
                         }
                     })
                     .collect()
-            }
-            DistanceMetric::DotProduct => {
-                query
-                    .iter()
-                    .zip(result.iter())
-                    .enumerate()
-                    .map(|(i, (q, r))| {
-                        let contribution = q * r;
-                        let percentage = if total_similarity.abs() > 1e-9 {
-                            contribution / total_similarity * 100.0
-                        } else {
-                            0.0
-                        };
-                        DimensionContribution {
-                            index: i,
-                            contribution,
-                            percentage,
-                            query_value: *q,
-                            result_value: *r,
-                            label: self.get_dimension_label(i),
-                        }
-                    })
-                    .collect()
-            }
+            },
+            DistanceMetric::DotProduct => query
+                .iter()
+                .zip(result.iter())
+                .enumerate()
+                .map(|(i, (q, r))| {
+                    let contribution = q * r;
+                    let percentage = if total_similarity.abs() > 1e-9 {
+                        contribution / total_similarity * 100.0
+                    } else {
+                        0.0
+                    };
+                    DimensionContribution {
+                        index: i,
+                        contribution,
+                        percentage,
+                        query_value: *q,
+                        result_value: *r,
+                        label: self.get_dimension_label(i),
+                    }
+                })
+                .collect(),
             DistanceMetric::Euclidean => {
                 // For Euclidean, contribution is negative of squared difference
                 let total_dist_sq: f32 = query
@@ -409,7 +405,7 @@ impl ExplainableSearch {
                         }
                     })
                     .collect()
-            }
+            },
         }
     }
 
@@ -426,10 +422,7 @@ impl ExplainableSearch {
         bottom: &[DimensionContribution],
         score: f32,
     ) -> String {
-        let mut summary = format!(
-            "Similarity score: {:.4} ({:?}). ",
-            score, self.metric
-        );
+        let mut summary = format!("Similarity score: {:.4} ({:?}). ", score, self.metric);
 
         if !top.is_empty() {
             let top_dims: Vec<String> = top
@@ -507,10 +500,7 @@ impl ExplainableSearch {
             .collect();
 
         let summary = if !shared_themes.is_empty() {
-            format!(
-                "Vectors match on themes: {}",
-                shared_themes.join(", ")
-            )
+            format!("Vectors match on themes: {}", shared_themes.join(", "))
         } else if !matching_features.is_empty() {
             format!("Similarity driven by: {}", matching_features[0])
         } else {
@@ -525,12 +515,7 @@ impl ExplainableSearch {
         }
     }
 
-    fn compute_confidence(
-        &self,
-        query: &[f32],
-        result: &[f32],
-        score: f32,
-    ) -> ConfidenceInfo {
+    fn compute_confidence(&self, query: &[f32], result: &[f32], score: f32) -> ConfidenceInfo {
         // Estimate confidence based on vector properties
         let dim = query.len() as f32;
 
@@ -571,7 +556,8 @@ impl ExplainableSearch {
             .iter()
             .filter(|c| c.contribution < 0.0)
             .collect();
-        negative_dims.sort_by(|a, b| OrderedFloat(a.contribution).cmp(&OrderedFloat(b.contribution)));
+        negative_dims
+            .sort_by(|a, b| OrderedFloat(a.contribution).cmp(&OrderedFloat(b.contribution)));
 
         if let Some(worst) = negative_dims.first() {
             let hypothetical: Vec<f32> = result
@@ -648,15 +634,29 @@ impl ExplainableSearch {
         info.insert("query_norm".to_string(), format!("{:.6}", query_norm));
         info.insert("result_norm".to_string(), format!("{:.6}", result_norm));
 
-        let positive_contribs: usize = contributions.iter().filter(|c| c.contribution > 0.0).count();
-        let negative_contribs: usize = contributions.iter().filter(|c| c.contribution < 0.0).count();
+        let positive_contribs: usize = contributions
+            .iter()
+            .filter(|c| c.contribution > 0.0)
+            .count();
+        let negative_contribs: usize = contributions
+            .iter()
+            .filter(|c| c.contribution < 0.0)
+            .count();
         info.insert("positive_dims".to_string(), positive_contribs.to_string());
         info.insert("negative_dims".to_string(), negative_contribs.to_string());
 
-        let sparsity_q = query.iter().filter(|&&x| x.abs() < 1e-6).count() as f32 / query.len() as f32;
-        let sparsity_r = result.iter().filter(|&&x| x.abs() < 1e-6).count() as f32 / result.len() as f32;
-        info.insert("query_sparsity".to_string(), format!("{:.2}%", sparsity_q * 100.0));
-        info.insert("result_sparsity".to_string(), format!("{:.2}%", sparsity_r * 100.0));
+        let sparsity_q =
+            query.iter().filter(|&&x| x.abs() < 1e-6).count() as f32 / query.len() as f32;
+        let sparsity_r =
+            result.iter().filter(|&&x| x.abs() < 1e-6).count() as f32 / result.len() as f32;
+        info.insert(
+            "query_sparsity".to_string(),
+            format!("{:.2}%", sparsity_q * 100.0),
+        );
+        info.insert(
+            "result_sparsity".to_string(),
+            format!("{:.2}%", sparsity_r * 100.0),
+        );
 
         info
     }
diff --git a/src/federation.rs b/src/federation.rs
index 791acb4..3e2a7d8 100644
--- a/src/federation.rs
+++ b/src/federation.rs
@@ -224,29 +224,34 @@ impl Federation {
             avg_latency_ms: RwLock::new(0.0),
         });
 
-        let mut members = self.members.write()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on members".into()))?;
+        let mut members = self.members.write().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire write lock on members".into())
+        })?;
         members.insert(member.id.clone(), state);
         Ok(())
     }
 
     /// Remove a member from the federation
     pub fn remove_member(&self, member_id: &str) -> Result<()> {
-        let mut members = self.members.write()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on members".into()))?;
-        members.remove(member_id)
+        let mut members = self.members.write().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire write lock on members".into())
+        })?;
+        members
+            .remove(member_id)
             .ok_or_else(|| VecStoreError::NotFound(format!("Member {} not found", member_id)))?;
         Ok(())
     }
 
     /// Update member configuration
     pub fn update_member(&self, member: FederationMember) -> Result<()> {
-        let mut members = self.members.write()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on members".into()))?;
+        let mut members = self.members.write().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire write lock on members".into())
+        })?;
         if let Some(state) = members.get_mut(&member.id) {
             // Create new state preserving runtime info
-            let avg_latency = *state.avg_latency_ms.read()
-                .map_err(|_| VecStoreError::LockError("Failed to acquire read lock on avg_latency_ms".into()))?;
+            let avg_latency = *state.avg_latency_ms.read().map_err(|_| {
+                VecStoreError::LockError("Failed to acquire read lock on avg_latency_ms".into())
+            })?;
             let new_state = Arc::new(MemberState {
                 member,
                 health: state.health.clone(),
@@ -259,7 +264,10 @@ impl Federation {
             members.insert(new_state.member.id.clone(), new_state);
             Ok(())
         } else {
-            Err(VecStoreError::NotFound(format!("Member {} not found", member.id)))
+            Err(VecStoreError::NotFound(format!(
+                "Member {} not found",
+                member.id
+            )))
         }
     }
 
@@ -310,10 +318,10 @@ impl Federation {
                 Ok(results) => {
                     all_results.extend(results);
                     members_succeeded += 1;
-                }
+                },
                 Err(_) => {
                     member_state.total_errors.fetch_add(1, Ordering::Relaxed);
-                }
+                },
             }
 
             member_state.active_queries.fetch_sub(1, Ordering::Relaxed);
@@ -345,8 +353,9 @@ impl Federation {
     }
 
     fn get_eligible_members(&self, query: &FederatedQuery) -> Result<Vec<Arc<MemberState>>> {
-        let members = self.members.read()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire read lock on members".into()))?;
+        let members = self.members.read().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire read lock on members".into())
+        })?;
         let mut eligible = Vec::new();
 
         for state in members.values() {
@@ -365,7 +374,9 @@ impl Federation {
 
             // Filter by collection if specified
             if !query.collections.is_empty() {
-                let has_collection = query.collections.iter()
+                let has_collection = query
+                    .collections
+                    .iter()
                     .any(|c| state.member.collections.contains(c));
                 if !has_collection {
                     continue;
@@ -381,13 +392,20 @@ impl Federation {
         Ok(eligible)
     }
 
-    fn query_member(&self, state: &MemberState, _query: &FederatedQuery) -> Result<Vec<MemberResult>> {
+    fn query_member(
+        &self,
+        state: &MemberState,
+        query: &FederatedQuery,
+    ) -> Result<Vec<MemberResult>> {
+        // Some feature combinations compile only the local-member branch.
+        let _ = query;
+
         match &state.member.member_type {
             MemberType::Local => {
                 // Local queries should be handled by the local VecStore directly
                 // Return empty results as local stores are queried separately
                 Ok(Vec::new())
-            }
+            },
             MemberType::RemoteHttp => {
                 #[cfg(feature = "openai-embeddings")]
                 {
@@ -400,7 +418,7 @@ impl Federation {
                         "HTTP federation requires 'openai-embeddings' feature (which includes reqwest)".into()
                     ))
                 }
-            }
+            },
             MemberType::RemoteGrpc => {
                 #[cfg(feature = "server")]
                 {
@@ -410,10 +428,10 @@ impl Federation {
                 #[cfg(not(feature = "server"))]
                 {
                     Err(VecStoreError::InvalidConfig(
-                        "gRPC federation requires 'server' feature (which includes tonic)".into()
+                        "gRPC federation requires 'server' feature (which includes tonic)".into(),
                     ))
                 }
-            }
+            },
             MemberType::External(service_type) => {
                 #[cfg(feature = "openai-embeddings")]
                 {
@@ -427,7 +445,7 @@ impl Federation {
                         "External federation requires 'openai-embeddings' feature (which includes reqwest)".into()
                     ))
                 }
-            }
+            },
         }
     }
 
@@ -487,7 +505,9 @@ impl Federation {
                             score: item.get("score")?.as_f64()? as f32,
                             vector: item.get("vector").and_then(|v| {
                                 v.as_array().map(|arr| {
-                                    arr.iter().filter_map(|x| x.as_f64().map(|n| n as f32)).collect()
+                                    arr.iter()
+                                        .filter_map(|x| x.as_f64().map(|n| n as f32))
+                                        .collect()
                                 })
                             }),
                             metadata: item.get("metadata").cloned(),
@@ -559,9 +579,9 @@ impl Federation {
             )));
         }
 
-        let body: serde_json::Value = response
-            .json()
-            .map_err(|e| VecStoreError::Internal(format!("Failed to parse Pinecone response: {}", e)))?;
+        let body: serde_json::Value = response.json().map_err(|e| {
+            VecStoreError::Internal(format!("Failed to parse Pinecone response: {}", e))
+        })?;
 
         let results = body
             .get("matches")
@@ -574,7 +594,9 @@ impl Federation {
                             score: item.get("score")?.as_f64()? as f32,
                             vector: item.get("values").and_then(|v| {
                                 v.as_array().map(|arr| {
-                                    arr.iter().filter_map(|x| x.as_f64().map(|n| n as f32)).collect()
+                                    arr.iter()
+                                        .filter_map(|x| x.as_f64().map(|n| n as f32))
+                                        .collect()
                                 })
                             }),
                             metadata: item.get("metadata").cloned(),
@@ -598,7 +620,11 @@ impl Federation {
         query: &FederatedQuery,
         k: usize,
     ) -> Result<Vec<MemberResult>> {
-        let collection = member.collections.first().cloned().unwrap_or_else(|| "default".to_string());
+        let collection = member
+            .collections
+            .first()
+            .cloned()
+            .unwrap_or_else(|| "default".to_string());
         let request_body = serde_json::json!({
             "vector": query.vector,
             "limit": k,
@@ -625,9 +651,9 @@ impl Federation {
             )));
         }
 
-        let body: serde_json::Value = response
-            .json()
-            .map_err(|e| VecStoreError::Internal(format!("Failed to parse Qdrant response: {}", e)))?;
+        let body: serde_json::Value = response.json().map_err(|e| {
+            VecStoreError::Internal(format!("Failed to parse Qdrant response: {}", e))
+        })?;
 
         let results = body
             .get("result")
@@ -640,7 +666,9 @@ impl Federation {
                             score: item.get("score")?.as_f64()? as f32,
                             vector: item.get("vector").and_then(|v| {
                                 v.as_array().map(|arr| {
-                                    arr.iter().filter_map(|x| x.as_f64().map(|n| n as f32)).collect()
+                                    arr.iter()
+                                        .filter_map(|x| x.as_f64().map(|n| n as f32))
+                                        .collect()
                                 })
                             }),
                             metadata: item.get("payload").cloned(),
@@ -664,7 +692,11 @@ impl Federation {
         query: &FederatedQuery,
         k: usize,
     ) -> Result<Vec<MemberResult>> {
-        let class_name = member.collections.first().cloned().unwrap_or_else(|| "Document".to_string());
+        let class_name = member
+            .collections
+            .first()
+            .cloned()
+            .unwrap_or_else(|| "Document".to_string());
 
         // Weaviate uses GraphQL
         let graphql_query = format!(
@@ -701,9 +733,9 @@ impl Federation {
             )));
         }
 
-        let body: serde_json::Value = response
-            .json()
-            .map_err(|e| VecStoreError::Internal(format!("Failed to parse Weaviate response: {}", e)))?;
+        let body: serde_json::Value = response.json().map_err(|e| {
+            VecStoreError::Internal(format!("Failed to parse Weaviate response: {}", e))
+        })?;
 
         // Parse GraphQL response
         let results = body
@@ -719,7 +751,9 @@ impl Federation {
                             score: 1.0 - additional.get("distance")?.as_f64()? as f32,
                             vector: additional.get("vector").and_then(|v| {
                                 v.as_array().map(|arr| {
-                                    arr.iter().filter_map(|x| x.as_f64().map(|n| n as f32)).collect()
+                                    arr.iter()
+                                        .filter_map(|x| x.as_f64().map(|n| n as f32))
+                                        .collect()
                                 })
                             }),
                             metadata: Some(item.clone()),
@@ -743,7 +777,11 @@ impl Federation {
         query: &FederatedQuery,
         k: usize,
     ) -> Result<Vec<MemberResult>> {
-        let collection = member.collections.first().cloned().unwrap_or_else(|| "default".to_string());
+        let collection = member
+            .collections
+            .first()
+            .cloned()
+            .unwrap_or_else(|| "default".to_string());
 
         let request_body = serde_json::json!({
             "query_embeddings": [query.vector],
@@ -770,15 +808,27 @@ impl Federation {
             )));
         }
 
-        let body: serde_json::Value = response
-            .json()
-            .map_err(|e| VecStoreError::Internal(format!("Failed to parse ChromaDB response: {}", e)))?;
+        let body: serde_json::Value = response.json().map_err(|e| {
+            VecStoreError::Internal(format!("Failed to parse ChromaDB response: {}", e))
+        })?;
 
         // ChromaDB returns arrays for each field
-        let ids = body.get("ids").and_then(|i| i.get(0)).and_then(|a| a.as_array());
-        let distances = body.get("distances").and_then(|d| d.get(0)).and_then(|a| a.as_array());
-        let embeddings = body.get("embeddings").and_then(|e| e.get(0)).and_then(|a| a.as_array());
-        let metadatas = body.get("metadatas").and_then(|m| m.get(0)).and_then(|a| a.as_array());
+        let ids = body
+            .get("ids")
+            .and_then(|i| i.get(0))
+            .and_then(|a| a.as_array());
+        let distances = body
+            .get("distances")
+            .and_then(|d| d.get(0))
+            .and_then(|a| a.as_array());
+        let embeddings = body
+            .get("embeddings")
+            .and_then(|e| e.get(0))
+            .and_then(|a| a.as_array());
+        let metadatas = body
+            .get("metadatas")
+            .and_then(|m| m.get(0))
+            .and_then(|a| a.as_array());
 
         let mut results = Vec::new();
         if let Some(ids) = ids {
@@ -793,7 +843,11 @@ impl Federation {
                     let vector = embeddings
                         .and_then(|e| e.get(i))
                         .and_then(|v| v.as_array())
-                        .map(|arr| arr.iter().filter_map(|x| x.as_f64().map(|n| n as f32)).collect());
+                        .map(|arr| {
+                            arr.iter()
+                                .filter_map(|x| x.as_f64().map(|n| n as f32))
+                                .collect()
+                        });
 
                     let metadata = metadatas.and_then(|m| m.get(i)).cloned();
 
@@ -820,18 +874,26 @@ impl Federation {
         query: &FederatedQuery,
         k: usize,
     ) -> Result<Vec<MemberResult>> {
-        use crate::server::types::pb::{vec_store_service_client::VecStoreServiceClient, QueryRequest};
+        use crate::server::types::pb::{
+            QueryRequest, vec_store_service_client::VecStoreServiceClient,
+        };
 
         // Create a tokio runtime for blocking on async gRPC calls
-        let rt = tokio::runtime::Runtime::new()
-            .map_err(|e| VecStoreError::Internal(format!("Failed to create tokio runtime: {}", e)))?;
+        let rt = tokio::runtime::Runtime::new().map_err(|e| {
+            VecStoreError::Internal(format!("Failed to create tokio runtime: {}", e))
+        })?;
 
         rt.block_on(async {
             // Connect to the gRPC server
             let endpoint = member.endpoint.clone();
             let mut client = VecStoreServiceClient::connect(endpoint.clone())
                 .await
-                .map_err(|e| VecStoreError::Internal(format!("gRPC connection failed to {}: {}", endpoint, e)))?;
+                .map_err(|e| {
+                    VecStoreError::Internal(format!(
+                        "gRPC connection failed to {}: {}",
+                        endpoint, e
+                    ))
+                })?;
 
             // Build the query request
             let request = QueryRequest {
@@ -842,13 +904,12 @@ impl Federation {
             };
 
             // Execute the query with timeout
-            let response = tokio::time::timeout(
-                self.config.member_timeout,
-                client.query(request)
-            )
-            .await
-            .map_err(|_| VecStoreError::Internal(format!("gRPC query timeout to {}", endpoint)))?
-            .map_err(|e| VecStoreError::Internal(format!("gRPC query failed: {}", e)))?;
+            let response = tokio::time::timeout(self.config.member_timeout, client.query(request))
+                .await
+                .map_err(|_| {
+                    VecStoreError::Internal(format!("gRPC query timeout to {}", endpoint))
+                })?
+                .map_err(|e| VecStoreError::Internal(format!("gRPC query failed: {}", e)))?;
 
             // Convert response to MemberResult
             let results: Vec<MemberResult> = response
@@ -876,11 +937,15 @@ impl Federation {
         })
     }
 
-    fn merge_results(&self, mut results: Vec<MemberResult>, query: &FederatedQuery) -> Vec<FederatedResult> {
+    fn merge_results(
+        &self,
+        mut results: Vec<MemberResult>,
+        query: &FederatedQuery,
+    ) -> Vec<FederatedResult> {
         match self.config.merge_strategy {
             MergeStrategy::ScoreBased => {
                 results.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap());
-            }
+            },
             MergeStrategy::RoundRobin => {
                 // Group by member, then interleave
                 let mut by_member: HashMap<String, Vec<MemberResult>> = HashMap::new();
@@ -897,11 +962,12 @@ impl Federation {
                         }
                     }
                 }
-            }
+            },
             MergeStrategy::Priority => {
                 // Already sorted by member priority, just sort within each member by score
                 results.sort_by(|a, b| {
-                    let member_cmp = self.get_member_priority(&b.member_id)
+                    let member_cmp = self
+                        .get_member_priority(&b.member_id)
                         .cmp(&self.get_member_priority(&a.member_id));
                     if member_cmp == std::cmp::Ordering::Equal {
                         b.score.partial_cmp(&a.score).unwrap()
@@ -909,7 +975,7 @@ impl Federation {
                         member_cmp
                     }
                 });
-            }
+            },
             MergeStrategy::Deduplicate => {
                 // Remove duplicates by ID, keeping highest score
                 let mut seen: HashMap<String, MemberResult> = HashMap::new();
@@ -924,7 +990,7 @@ impl Federation {
                 }
                 results = seen.into_values().collect();
                 results.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap());
-            }
+            },
             MergeStrategy::Weighted => {
                 // Apply member weights to scores
                 for r in &mut results {
@@ -932,7 +998,7 @@ impl Federation {
                     r.score *= weight;
                 }
                 results.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap());
-            }
+            },
         }
 
         // Apply min score filter
@@ -944,7 +1010,8 @@ impl Federation {
         results.truncate(query.k);
 
         // Convert to federated results
-        results.into_iter()
+        results
+            .into_iter()
             .map(|r| FederatedResult {
                 id: r.id,
                 score: r.score,
@@ -957,7 +1024,9 @@ impl Federation {
     }
 
     fn get_member_priority(&self, member_id: &str) -> u32 {
-        let Ok(members) = self.members.read() else { return 0; };
+        let Ok(members) = self.members.read() else {
+            return 0;
+        };
         members
             .get(member_id)
             .map(|s| s.member.priority)
@@ -965,7 +1034,9 @@ impl Federation {
     }
 
     fn get_member_weight(&self, member_id: &str) -> f32 {
-        let Ok(members) = self.members.read() else { return 1.0; };
+        let Ok(members) = self.members.read() else {
+            return 1.0;
+        };
         members
             .get(member_id)
             .map(|s| s.member.weight)
@@ -990,25 +1061,34 @@ impl Federation {
     }
 
     fn get_cached(&self, key: &str) -> Option<Vec<FederatedResult>> {
-        let Ok(cache) = self.cache.read() else { return None; };
+        let Ok(cache) = self.cache.read() else {
+            return None;
+        };
         if let Some(cached) = cache.get(key)
-            && cached.cached_at.elapsed() < self.config.cache_ttl {
-                return Some(cached.results.clone());
-            }
+            && cached.cached_at.elapsed() < self.config.cache_ttl
+        {
+            return Some(cached.results.clone());
+        }
         None
     }
 
     fn cache_result(&self, key: &str, results: Vec<FederatedResult>) {
-        let Ok(mut cache) = self.cache.write() else { return; };
-        cache.insert(key.to_string(), CachedResult {
-            results,
-            cached_at: Instant::now(),
-        });
+        let Ok(mut cache) = self.cache.write() else {
+            return;
+        };
+        cache.insert(
+            key.to_string(),
+            CachedResult {
+                results,
+                cached_at: Instant::now(),
+            },
+        );
 
         // Limit cache size
         if cache.len() > 10000 {
             // Remove oldest entries
-            let mut entries: Vec<_> = cache.iter()
+            let mut entries: Vec<_> = cache
+                .iter()
                 .map(|(k, v)| (k.clone(), v.cached_at))
                 .collect();
             entries.sort_by_key(|(_, t)| *t);
@@ -1021,10 +1101,14 @@ impl Federation {
 
     /// Update member health status
     pub fn update_health(&self, member_id: &str, _health: MemberHealth) -> Result<()> {
-        let members = self.members.read()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire read lock on members".into()))?;
+        let members = self.members.read().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire read lock on members".into())
+        })?;
         let Some(_state) = members.get(member_id) else {
-            return Err(VecStoreError::NotFound(format!("Member {} not found", member_id)));
+            return Err(VecStoreError::NotFound(format!(
+                "Member {} not found",
+                member_id
+            )));
         };
         // Can't mutate through Arc, but in production we'd use interior mutability
         Ok(())
@@ -1045,7 +1129,8 @@ impl Federation {
             };
         };
 
-        let member_statuses: Vec<MemberStatus> = members.values()
+        let member_statuses: Vec<MemberStatus> = members
+            .values()
             .map(|s| {
                 let avg_latency = s.avg_latency_ms.read().map(|g| *g).unwrap_or(0.0);
                 MemberStatus {
@@ -1062,7 +1147,8 @@ impl Federation {
             })
             .collect();
 
-        let healthy_count = member_statuses.iter()
+        let healthy_count = member_statuses
+            .iter()
             .filter(|m| m.health == MemberHealth::Healthy)
             .count();
 
@@ -1088,24 +1174,25 @@ impl Federation {
 
     /// List all members
     pub fn list_members(&self) -> Vec<FederationMember> {
-        let Ok(members) = self.members.read() else { return vec![]; };
-        members
-            .values()
-            .map(|s| s.member.clone())
-            .collect()
+        let Ok(members) = self.members.read() else {
+            return vec![];
+        };
+        members.values().map(|s| s.member.clone()).collect()
     }
 
     /// Get a specific member
     pub fn get_member(&self, member_id: &str) -> Option<FederationMember> {
-        let Ok(members) = self.members.read() else { return None; };
-        members
-            .get(member_id)
-            .map(|s| s.member.clone())
+        let Ok(members) = self.members.read() else {
+            return None;
+        };
+        members.get(member_id).map(|s| s.member.clone())
     }
 
     /// Clear cache
     pub fn clear_cache(&self) {
-        let Ok(mut cache) = self.cache.write() else { return; };
+        let Ok(mut cache) = self.cache.write() else {
+            return;
+        };
         cache.clear();
     }
 }
@@ -1301,7 +1388,7 @@ mod tests {
 
         // Results should be sorted by score
         for i in 1..result.results.len() {
-            assert!(result.results[i-1].score >= result.results[i].score);
+            assert!(result.results[i - 1].score >= result.results[i].score);
         }
     }
 
diff --git a/src/fuzzy.rs b/src/fuzzy.rs
index f134d82..3e15974 100644
--- a/src/fuzzy.rs
+++ b/src/fuzzy.rs
@@ -481,10 +481,10 @@ impl BKNode {
                 if distance < *best_dist {
                     *best = Some((self.word.clone(), distance));
                 }
-            }
+            },
             None => {
                 *best = Some((self.word.clone(), distance));
-            }
+            },
         }
 
         // Search children
diff --git a/src/generative.rs b/src/generative.rs
index 609c3ee..b78f47b 100644
--- a/src/generative.rs
+++ b/src/generative.rs
@@ -35,9 +35,9 @@
 //! println!("Sources: {:?}", response.citations);
 //! ```
 
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::Arc;
-use serde::{Deserialize, Serialize};
 
 use crate::error::Result;
 use crate::store::{Query, VecStore};
@@ -64,20 +64,11 @@ pub enum LLMProvider {
         max_tokens: Option<usize>,
     },
     /// Cohere Command models
-    Cohere {
-        model: String,
-        api_key: String,
-    },
+    Cohere { model: String, api_key: String },
     /// Google Gemini
-    Gemini {
-        model: String,
-        api_key: String,
-    },
+    Gemini { model: String, api_key: String },
     /// Ollama local models
-    Ollama {
-        model: String,
-        base_url: String,
-    },
+    Ollama { model: String, base_url: String },
     /// Azure OpenAI
     AzureOpenAI {
         deployment: String,
@@ -86,10 +77,7 @@ pub enum LLMProvider {
         api_version: String,
     },
     /// AWS Bedrock
-    Bedrock {
-        model_id: String,
-        region: String,
-    },
+    Bedrock { model_id: String, region: String },
     /// Custom HTTP endpoint
     Custom {
         endpoint: String,
@@ -154,17 +142,23 @@ fn default_prompt_template() -> String {
     "Answer the following question based on the provided context.\n\n\
      Context:\n{context}\n\n\
      Question: {query}\n\n\
-     Answer:".to_string()
+     Answer:"
+        .to_string()
 }
 
 fn default_system_prompt() -> String {
     "You are a helpful assistant that answers questions based on the provided context. \
      Be concise and accurate. If the context doesn't contain enough information, \
-     say so rather than making up an answer.".to_string()
+     say so rather than making up an answer."
+        .to_string()
 }
 
-fn default_true() -> bool { true }
-fn default_context_length() -> usize { 4000 }
+fn default_true() -> bool {
+    true
+}
+fn default_context_length() -> usize {
+    4000
+}
 
 impl GenerativeConfig {
     /// Create a new configuration
@@ -428,11 +422,7 @@ impl GenerativeSearch {
     }
 
     /// Generate a response for a query
-    pub fn generate(
-        &self,
-        query: &str,
-        options: GenerativeQuery,
-    ) -> Result<GenerativeResponse> {
+    pub fn generate(&self, query: &str, options: GenerativeQuery) -> Result<GenerativeResponse> {
         let start = std::time::Instant::now();
 
         // Step 1: Retrieve relevant documents (simulated)
@@ -488,14 +478,21 @@ impl GenerativeSearch {
 
             // Query the store
             let store_guard = store.read().map_err(|e| {
-                crate::error::VecStoreError::LockError(format!("Failed to acquire store lock: {}", e))
+                crate::error::VecStoreError::LockError(format!(
+                    "Failed to acquire store lock: {}",
+                    e
+                ))
             })?;
 
-            let results = store_guard.query(Query {
-                vector: query_vector,
-                k: options.limit,
-                filter: None, // Filter support planned for future release
-            }).map_err(|e| crate::error::VecStoreError::Internal(format!("Query failed: {}", e)))?;
+            let results = store_guard
+                .query(Query {
+                    vector: query_vector,
+                    k: options.limit,
+                    filter: None, // Filter support planned for future release
+                })
+                .map_err(|e| {
+                    crate::error::VecStoreError::Internal(format!("Query failed: {}", e))
+                })?;
 
             // Convert to RetrievedDocument format
             return Ok(results
@@ -522,7 +519,9 @@ impl GenerativeSearch {
                         id: neighbor.id,
                         content,
                         score: neighbor.score,
-                        metadata: Some(serde_json::to_value(&neighbor.metadata.fields).unwrap_or_default()),
+                        metadata: Some(
+                            serde_json::to_value(&neighbor.metadata.fields).unwrap_or_default(),
+                        ),
                     }
                 })
                 .collect());
@@ -530,7 +529,9 @@ impl GenerativeSearch {
 
         // Fallback: return placeholder documents when no store/embedder configured
         // Useful for testing RAG pipelines without full vector store setup
-        tracing::debug!("No store/embedder configured - returning placeholder documents for testing");
+        tracing::debug!(
+            "No store/embedder configured - returning placeholder documents for testing"
+        );
         Ok((0..options.limit.min(3))
             .map(|i| RetrievedDocument {
                 id: format!("placeholder_doc_{}", i),
@@ -554,11 +555,7 @@ impl GenerativeSearch {
         let mut context = String::new();
 
         for (i, doc) in docs.iter().enumerate() {
-            context.push_str(&format!(
-                "[{}] {}\n\n",
-                i + 1,
-                doc.content
-            ));
+            context.push_str(&format!("[{}] {}\n\n", i + 1, doc.content));
         }
 
         // Truncate if too long
@@ -577,7 +574,8 @@ impl GenerativeSearch {
         context: &str,
         options: &GenerativeQuery,
     ) -> Result<String> {
-        let template = options.prompt_template
+        let template = options
+            .prompt_template
             .as_ref()
             .unwrap_or(&self.config.prompt_template);
 
@@ -604,9 +602,7 @@ impl GenerativeSearch {
                 max_tokens,
             } => self.call_openai(prompt, model, api_key, *temperature, *max_tokens),
 
-            LLMProvider::Ollama { model, base_url } => {
-                self.call_ollama(prompt, model, base_url)
-            }
+            LLMProvider::Ollama { model, base_url } => self.call_ollama(prompt, model, base_url),
 
             // For other providers, return a message indicating they're not yet implemented
             _ => Ok(format!(
@@ -676,9 +672,9 @@ impl GenerativeSearch {
             )));
         }
 
-        let json: serde_json::Value = response
-            .json()
-            .map_err(|e| VecStoreError::Internal(format!("Failed to parse OpenAI response: {}", e)))?;
+        let json: serde_json::Value = response.json().map_err(|e| {
+            VecStoreError::Internal(format!("Failed to parse OpenAI response: {}", e))
+        })?;
 
         json["choices"][0]["message"]["content"]
             .as_str()
@@ -717,9 +713,9 @@ impl GenerativeSearch {
             )));
         }
 
-        let json: serde_json::Value = response
-            .json()
-            .map_err(|e| VecStoreError::Internal(format!("Failed to parse Ollama response: {}", e)))?;
+        let json: serde_json::Value = response.json().map_err(|e| {
+            VecStoreError::Internal(format!("Failed to parse Ollama response: {}", e))
+        })?;
 
         json["response"]
             .as_str()
@@ -921,10 +917,9 @@ mod tests {
         let config = GenerativeConfig::ollama("llama3");
         let gen_search = GenerativeSearch::new(config).unwrap();
 
-        let response = gen_search.generate(
-            "What is VecStore?",
-            GenerativeQuery::new().with_limit(3),
-        ).unwrap();
+        let response = gen_search
+            .generate("What is VecStore?", GenerativeQuery::new().with_limit(3))
+            .unwrap();
 
         assert!(!response.generated_text.is_empty());
         assert!(!response.citations.is_empty());
@@ -935,10 +930,9 @@ mod tests {
         let config = GenerativeConfig::ollama("llama3");
         let gen_search = GenerativeSearch::new(config).unwrap();
 
-        let stream = gen_search.generate_stream(
-            "What is VecStore?",
-            GenerativeQuery::new(),
-        ).unwrap();
+        let stream = gen_search
+            .generate_stream("What is VecStore?", GenerativeQuery::new())
+            .unwrap();
 
         let chunks: Vec<_> = stream.collect();
         assert!(!chunks.is_empty());
diff --git a/src/geospatial.rs b/src/geospatial.rs
index a162eab..8794d0b 100644
--- a/src/geospatial.rs
+++ b/src/geospatial.rs
@@ -31,7 +31,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -191,10 +191,7 @@ impl GeoIndex {
         let cell_id = location.s2_cell_id(self.s2_level);
 
         // Add to cell index
-        self.cell_index
-            .entry(cell_id)
-            .or_default()
-            .push(id.clone());
+        self.cell_index.entry(cell_id).or_default().push(id.clone());
 
         // Add document
         let doc = GeoDocument {
diff --git a/src/gpu.rs b/src/gpu.rs
index 01355dd..d5e4d49 100644
--- a/src/gpu.rs
+++ b/src/gpu.rs
@@ -98,7 +98,7 @@
 pub mod cuda_kernels;
 pub mod metal_executor;
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 
@@ -253,7 +253,7 @@ impl GpuExecutor {
                     {
                         return Err(anyhow!("CUDA support not compiled. Enable 'cuda' feature."));
                     }
-                }
+                },
                 GpuBackend::Metal => {
                     #[cfg(feature = "metal")]
                     {
@@ -265,10 +265,10 @@ impl GpuExecutor {
                             "Metal support not compiled. Enable 'metal' feature."
                         ));
                     }
-                }
+                },
                 GpuBackend::Cpu => {
                     return Ok(Arc::new(CpuBackend::new(config)));
-                }
+                },
                 GpuBackend::WebGpu => {
                     #[cfg(feature = "webgpu")]
                     {
@@ -282,7 +282,7 @@ impl GpuExecutor {
                     {
                         return Err(anyhow!("WebGPU requires 'webgpu' feature"));
                     }
-                }
+                },
             }
         }
 
@@ -552,7 +552,10 @@ impl GpuOps for CudaBackend {
             name: props.name,
             total_memory_bytes: props.total_memory_bytes,
             available_memory_bytes: props.total_memory_bytes, // Approximation
-            compute_capability: (props.compute_capability.0 as u32, props.compute_capability.1 as u32),
+            compute_capability: (
+                props.compute_capability.0 as u32,
+                props.compute_capability.1 as u32,
+            ),
             max_threads_per_block: props.max_threads_per_block as usize,
             num_streaming_multiprocessors: props.multiprocessor_count as usize,
         }
@@ -570,7 +573,8 @@ impl GpuOps for CudaBackend {
         let flat_database: Vec<f32> = database.iter().flat_map(|v| v.iter().copied()).collect();
 
         // Execute GPU kernel
-        self.executor.euclidean_distance(query, &flat_database, num_vectors, vector_dim)
+        self.executor
+            .euclidean_distance(query, &flat_database, num_vectors, vector_dim)
     }
 
     fn batch_cosine_similarity(&self, query: &[f32], database: &[Vec<f32>]) -> Result<Vec<f32>> {
@@ -583,7 +587,8 @@ impl GpuOps for CudaBackend {
 
         let flat_database: Vec<f32> = database.iter().flat_map(|v| v.iter().copied()).collect();
 
-        self.executor.cosine_similarity(query, &flat_database, num_vectors, vector_dim)
+        self.executor
+            .cosine_similarity(query, &flat_database, num_vectors, vector_dim)
     }
 
     fn batch_dot_product(&self, query: &[f32], database: &[Vec<f32>]) -> Result<Vec<f32>> {
@@ -596,7 +601,8 @@ impl GpuOps for CudaBackend {
 
         let flat_database: Vec<f32> = database.iter().flat_map(|v| v.iter().copied()).collect();
 
-        self.executor.dot_product(query, &flat_database, num_vectors, vector_dim)
+        self.executor
+            .dot_product(query, &flat_database, num_vectors, vector_dim)
     }
 
     fn matrix_multiply(&self, a: &[Vec<f32>], b: &[Vec<f32>]) -> Result<Vec<Vec<f32>>> {
@@ -615,7 +621,9 @@ impl GpuOps for CudaBackend {
 
         let flat_vectors: Vec<f32> = vectors.iter().flat_map(|v| v.iter().copied()).collect();
 
-        let normalized = self.executor.l2_normalize(&flat_vectors, num_vectors, vector_dim)?;
+        let normalized = self
+            .executor
+            .l2_normalize(&flat_vectors, num_vectors, vector_dim)?;
 
         // Reshape back to Vec<Vec<f32>>
         Ok(normalized.chunks(vector_dim).map(|c| c.to_vec()).collect())
@@ -646,9 +654,7 @@ impl GpuOps for CudaBackend {
 // ============================================================================
 
 #[cfg(all(target_os = "macos", feature = "metal"))]
-use metal::{
-    Buffer, CommandQueue, ComputePipelineState, Device, MTLResourceOptions, MTLSize,
-};
+use metal::{Buffer, CommandQueue, ComputePipelineState, Device, MTLResourceOptions, MTLSize};
 
 /// Metal Shading Language source code for compute kernels
 #[cfg(all(target_os = "macos", feature = "metal"))]
@@ -797,8 +803,8 @@ impl MetalBackend {
     /// Create a new Metal backend with GPU device initialization
     pub fn new(config: &GpuConfig) -> Result<Self> {
         // Get the system default Metal device
-        let device = Device::system_default()
-            .ok_or_else(|| anyhow!("No Metal-capable GPU device found"))?;
+        let device =
+            Device::system_default().ok_or_else(|| anyhow!("No Metal-capable GPU device found"))?;
 
         // Create command queue for submitting work to GPU
         let command_queue = device.new_command_queue();
@@ -809,7 +815,8 @@ impl MetalBackend {
             .map_err(|e| anyhow!("Failed to compile Metal shaders: {}", e))?;
 
         // Create compute pipeline states for each kernel
-        let euclidean_pipeline = Self::create_pipeline(&device, &library, "euclidean_distance_kernel")?;
+        let euclidean_pipeline =
+            Self::create_pipeline(&device, &library, "euclidean_distance_kernel")?;
         let cosine_pipeline = Self::create_pipeline(&device, &library, "cosine_similarity_kernel")?;
         let dot_product_pipeline = Self::create_pipeline(&device, &library, "dot_product_kernel")?;
         let normalize_pipeline = Self::create_pipeline(&device, &library, "l2_normalize_kernel")?;
@@ -861,7 +868,8 @@ impl MetalBackend {
     /// Create an empty Metal buffer for output
     fn create_output_buffer(&self, num_elements: usize) -> Buffer {
         let size = (num_elements * size_of::<f32>()) as u64;
-        self.device.new_buffer(size, MTLResourceOptions::StorageModeShared)
+        self.device
+            .new_buffer(size, MTLResourceOptions::StorageModeShared)
     }
 
     /// Read results from a Metal buffer back to CPU
@@ -951,7 +959,8 @@ impl GpuOps for MetalBackend {
             total_memory_bytes: recommended_max,
             available_memory_bytes: recommended_max, // Unified memory, estimation
             compute_capability: (supports_family.0, supports_family.1),
-            max_threads_per_block: self.euclidean_pipeline.max_total_threads_per_threadgroup() as usize,
+            max_threads_per_block: self.euclidean_pipeline.max_total_threads_per_threadgroup()
+                as usize,
             num_streaming_multiprocessors: 10, // Not directly exposed by Metal API
         }
     }
@@ -969,7 +978,9 @@ impl GpuOps for MetalBackend {
             if vec.len() != vector_dim {
                 return Err(anyhow!(
                     "Vector {} has dimension {} but query has dimension {}",
-                    i, vec.len(), vector_dim
+                    i,
+                    vec.len(),
+                    vector_dim
                 ));
             }
         }
@@ -999,7 +1010,9 @@ impl GpuOps for MetalBackend {
             if vec.len() != vector_dim {
                 return Err(anyhow!(
                     "Vector {} has dimension {} but query has dimension {}",
-                    i, vec.len(), vector_dim
+                    i,
+                    vec.len(),
+                    vector_dim
                 ));
             }
         }
@@ -1029,7 +1042,9 @@ impl GpuOps for MetalBackend {
             if vec.len() != vector_dim {
                 return Err(anyhow!(
                     "Vector {} has dimension {} but query has dimension {}",
-                    i, vec.len(), vector_dim
+                    i,
+                    vec.len(),
+                    vector_dim
                 ));
             }
         }
@@ -1051,15 +1066,18 @@ impl GpuOps for MetalBackend {
             return Ok(vec![]);
         }
 
-        let m = a.len();         // rows of A
-        let k = a[0].len();      // cols of A = rows of B
-        let n = b[0].len();      // cols of B
+        let m = a.len(); // rows of A
+        let k = a[0].len(); // cols of A = rows of B
+        let n = b[0].len(); // cols of B
 
         // Validate dimensions
         if b.len() != k {
             return Err(anyhow!(
                 "Matrix dimension mismatch: A is {}x{}, B is {}x{}",
-                m, k, b.len(), n
+                m,
+                k,
+                b.len(),
+                n
             ));
         }
 
@@ -1132,7 +1150,9 @@ impl GpuOps for MetalBackend {
             if vec.len() != vector_dim {
                 return Err(anyhow!(
                     "Vector {} has dimension {} but expected {}",
-                    i, vec.len(), vector_dim
+                    i,
+                    vec.len(),
+                    vector_dim
                 ));
             }
         }
@@ -1211,9 +1231,7 @@ impl GpuOps for MetalBackend {
 
         // Partial sort for efficiency when k << n
         if k < indexed.len() / 2 {
-            indexed.select_nth_unstable_by(k, |a, b| {
-                a.1.total_cmp(&b.1)
-            });
+            indexed.select_nth_unstable_by(k, |a, b| a.1.total_cmp(&b.1));
             indexed.truncate(k);
             indexed.sort_by(|a, b| a.1.total_cmp(&b.1));
         } else {
@@ -1539,43 +1557,29 @@ impl WebGpuBackend {
 
         // Request device with reasonable limits for compute
         let (device, queue) = adapter
-            .request_device(
-                &wgpu::DeviceDescriptor {
-                    label: Some("VecStore WebGPU Device"),
-                    required_features: wgpu::Features::empty(),
-                    required_limits: wgpu::Limits::default(),
-                    memory_hints: wgpu::MemoryHints::default(),
-                    trace: wgpu::Trace::default(),
-                    experimental_features: wgpu::ExperimentalFeatures::default(),
-                },
-            )
+            .request_device(&wgpu::DeviceDescriptor {
+                label: Some("VecStore WebGPU Device"),
+                required_features: wgpu::Features::empty(),
+                required_limits: wgpu::Limits::default(),
+                memory_hints: wgpu::MemoryHints::default(),
+                trace: wgpu::Trace::default(),
+                experimental_features: wgpu::ExperimentalFeatures::default(),
+            })
             .await
             .map_err(|e| anyhow!("Failed to create WebGPU device: {}", e))?;
 
         // Compile all compute shaders and create pipelines
-        let euclidean_pipeline = Self::create_compute_pipeline(
-            &device,
-            WGSL_EUCLIDEAN_DISTANCE,
-            "euclidean_distance",
-        )?;
-
-        let cosine_pipeline = Self::create_compute_pipeline(
-            &device,
-            WGSL_COSINE_SIMILARITY,
-            "cosine_similarity",
-        )?;
-
-        let dot_product_pipeline = Self::create_compute_pipeline(
-            &device,
-            WGSL_DOT_PRODUCT,
-            "dot_product",
-        )?;
-
-        let normalize_pipeline = Self::create_compute_pipeline(
-            &device,
-            WGSL_L2_NORMALIZE,
-            "l2_normalize",
-        )?;
+        let euclidean_pipeline =
+            Self::create_compute_pipeline(&device, WGSL_EUCLIDEAN_DISTANCE, "euclidean_distance")?;
+
+        let cosine_pipeline =
+            Self::create_compute_pipeline(&device, WGSL_COSINE_SIMILARITY, "cosine_similarity")?;
+
+        let dot_product_pipeline =
+            Self::create_compute_pipeline(&device, WGSL_DOT_PRODUCT, "dot_product")?;
+
+        let normalize_pipeline =
+            Self::create_compute_pipeline(&device, WGSL_L2_NORMALIZE, "l2_normalize")?;
 
         Ok(Self {
             config: config.clone(),
@@ -1646,17 +1650,21 @@ impl WebGpuBackend {
         use wgpu::util::DeviceExt;
 
         // Create GPU buffers
-        let query_buffer = self.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-            label: Some("Query Buffer"),
-            contents: bytemuck::cast_slice(query),
-            usage: wgpu::BufferUsages::STORAGE,
-        });
+        let query_buffer = self
+            .device
+            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: Some("Query Buffer"),
+                contents: bytemuck::cast_slice(query),
+                usage: wgpu::BufferUsages::STORAGE,
+            });
 
-        let database_buffer = self.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-            label: Some("Database Buffer"),
-            contents: bytemuck::cast_slice(database),
-            usage: wgpu::BufferUsages::STORAGE,
-        });
+        let database_buffer = self
+            .device
+            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: Some("Database Buffer"),
+                contents: bytemuck::cast_slice(database),
+                usage: wgpu::BufferUsages::STORAGE,
+            });
 
         // Output buffer (results)
         let output_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
@@ -1681,11 +1689,13 @@ impl WebGpuBackend {
             _padding0: 0,
             _padding1: 0,
         };
-        let params_buffer = self.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-            label: Some("Params Buffer"),
-            contents: bytemuck::cast_slice(&[params]),
-            usage: wgpu::BufferUsages::UNIFORM,
-        });
+        let params_buffer = self
+            .device
+            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: Some("Params Buffer"),
+                contents: bytemuck::cast_slice(&[params]),
+                usage: wgpu::BufferUsages::UNIFORM,
+            });
 
         // Create bind group
         let bind_group_layout = pipeline.get_bind_group_layout(0);
@@ -1713,9 +1723,11 @@ impl WebGpuBackend {
         });
 
         // Create and submit command buffer
-        let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
-            label: Some("Compute Encoder"),
-        });
+        let mut encoder = self
+            .device
+            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
+                label: Some("Compute Encoder"),
+            });
 
         {
             let mut compute_pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
@@ -1749,10 +1761,12 @@ impl WebGpuBackend {
         });
 
         // Poll the device until the buffer is mapped
-        self.device.poll(wgpu::PollType::Wait {
-            submission_index: None,
-            timeout: Some(std::time::Duration::from_secs(60)),
-        }).map_err(|e| anyhow!("GPU poll failed: {:?}", e))?;
+        self.device
+            .poll(wgpu::PollType::Wait {
+                submission_index: None,
+                timeout: Some(std::time::Duration::from_secs(60)),
+            })
+            .map_err(|e| anyhow!("GPU poll failed: {:?}", e))?;
 
         receiver
             .recv()
@@ -1779,11 +1793,13 @@ impl WebGpuBackend {
         let total_elements = num_vectors * vector_dim;
 
         // Create GPU buffers
-        let input_buffer = self.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-            label: Some("Input Buffer"),
-            contents: bytemuck::cast_slice(input),
-            usage: wgpu::BufferUsages::STORAGE,
-        });
+        let input_buffer = self
+            .device
+            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: Some("Input Buffer"),
+                contents: bytemuck::cast_slice(input),
+                usage: wgpu::BufferUsages::STORAGE,
+            });
 
         // Output buffer
         let output_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
@@ -1808,11 +1824,13 @@ impl WebGpuBackend {
             _padding0: 0,
             _padding1: 0,
         };
-        let params_buffer = self.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-            label: Some("Params Buffer"),
-            contents: bytemuck::cast_slice(&[params]),
-            usage: wgpu::BufferUsages::UNIFORM,
-        });
+        let params_buffer = self
+            .device
+            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: Some("Params Buffer"),
+                contents: bytemuck::cast_slice(&[params]),
+                usage: wgpu::BufferUsages::UNIFORM,
+            });
 
         // Create bind group
         let bind_group_layout = self.normalize_pipeline.get_bind_group_layout(0);
@@ -1836,9 +1854,11 @@ impl WebGpuBackend {
         });
 
         // Create and submit command buffer
-        let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
-            label: Some("Normalize Encoder"),
-        });
+        let mut encoder = self
+            .device
+            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
+                label: Some("Normalize Encoder"),
+            });
 
         {
             let mut compute_pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
@@ -1869,10 +1889,12 @@ impl WebGpuBackend {
             let _ = sender.send(result);
         });
 
-        self.device.poll(wgpu::PollType::Wait {
-            submission_index: None,
-            timeout: Some(std::time::Duration::from_secs(60)),
-        }).map_err(|e| anyhow!("GPU poll failed: {:?}", e))?;
+        self.device
+            .poll(wgpu::PollType::Wait {
+                submission_index: None,
+                timeout: Some(std::time::Duration::from_secs(60)),
+            })
+            .map_err(|e| anyhow!("GPU poll failed: {:?}", e))?;
 
         receiver
             .recv()
@@ -1931,11 +1953,14 @@ impl GpuOps for WebGpuBackend {
         GpuDeviceInfo {
             backend: GpuBackend::WebGpu,
             device_id: self.config.device_id,
-            name: format!("{} ({:?})", self.adapter_info.name, self.adapter_info.backend),
+            name: format!(
+                "{} ({:?})",
+                self.adapter_info.name, self.adapter_info.backend
+            ),
             total_memory_bytes: self.config.max_memory_bytes,
             available_memory_bytes: self.config.max_memory_bytes,
-            compute_capability: (1, 0), // WebGPU version indicator
-            max_threads_per_block: 256, // Workgroup size
+            compute_capability: (1, 0),       // WebGPU version indicator
+            max_threads_per_block: 256,       // Workgroup size
             num_streaming_multiprocessors: 1, // Not directly available in WebGPU
         }
     }
@@ -1951,7 +1976,9 @@ impl GpuOps for WebGpuBackend {
             if vec.len() != vector_dim {
                 return Err(anyhow!(
                     "Database vector {} has dimension {} but query has dimension {}",
-                    i, vec.len(), vector_dim
+                    i,
+                    vec.len(),
+                    vector_dim
                 ));
             }
         }
@@ -1971,7 +1998,9 @@ impl GpuOps for WebGpuBackend {
             if vec.len() != vector_dim {
                 return Err(anyhow!(
                     "Database vector {} has dimension {} but query has dimension {}",
-                    i, vec.len(), vector_dim
+                    i,
+                    vec.len(),
+                    vector_dim
                 ));
             }
         }
@@ -1991,7 +2020,9 @@ impl GpuOps for WebGpuBackend {
             if vec.len() != vector_dim {
                 return Err(anyhow!(
                     "Database vector {} has dimension {} but query has dimension {}",
-                    i, vec.len(), vector_dim
+                    i,
+                    vec.len(),
+                    vector_dim
                 ));
             }
         }
@@ -2022,7 +2053,9 @@ impl GpuOps for WebGpuBackend {
             if vec.len() != vector_dim {
                 return Err(anyhow!(
                     "Vector {} has dimension {} but expected {}",
-                    i, vec.len(), vector_dim
+                    i,
+                    vec.len(),
+                    vector_dim
                 ));
             }
         }
@@ -2061,9 +2094,7 @@ impl GpuOps for WebGpuBackend {
         // Partial sort to get top k (more efficient than full sort for small k)
         let k = k.min(indexed.len());
         if k < indexed.len() {
-            indexed.select_nth_unstable_by(k, |a, b| {
-                a.1.total_cmp(&b.1)
-            });
+            indexed.select_nth_unstable_by(k, |a, b| a.1.total_cmp(&b.1));
             indexed.truncate(k);
         }
 
@@ -2351,7 +2382,10 @@ mod tests {
 
         #[test]
         fn test_metal_is_available() {
-            assert!(MetalBackend::is_available(), "Metal should be available on macOS");
+            assert!(
+                MetalBackend::is_available(),
+                "Metal should be available on macOS"
+            );
         }
 
         #[test]
@@ -2373,16 +2407,19 @@ mod tests {
 
             let query = vec![1.0, 2.0, 3.0, 4.0];
             let database = vec![
-                vec![1.0, 2.0, 3.0, 4.0],  // Same as query
-                vec![2.0, 3.0, 4.0, 5.0],  // Different
-                vec![0.0, 0.0, 0.0, 0.0],  // Origin
+                vec![1.0, 2.0, 3.0, 4.0], // Same as query
+                vec![2.0, 3.0, 4.0, 5.0], // Different
+                vec![0.0, 0.0, 0.0, 0.0], // Origin
             ];
 
             let distances = backend.batch_euclidean_distance(&query, &database).unwrap();
 
             assert_eq!(distances.len(), 3);
             assert!(distances[0] < 0.001, "Same vector should have distance ~0");
-            assert!(distances[1] > 1.0, "Different vector should have larger distance");
+            assert!(
+                distances[1] > 1.0,
+                "Different vector should have larger distance"
+            );
             assert!(distances[2] > 5.0, "Origin should have large distance");
         }
 
@@ -2393,17 +2430,23 @@ mod tests {
 
             let query = vec![1.0, 0.0, 0.0, 0.0];
             let database = vec![
-                vec![1.0, 0.0, 0.0, 0.0],   // Same direction
-                vec![0.0, 1.0, 0.0, 0.0],   // Perpendicular
-                vec![-1.0, 0.0, 0.0, 0.0],  // Opposite
+                vec![1.0, 0.0, 0.0, 0.0],  // Same direction
+                vec![0.0, 1.0, 0.0, 0.0],  // Perpendicular
+                vec![-1.0, 0.0, 0.0, 0.0], // Opposite
             ];
 
             let similarities = backend.batch_cosine_similarity(&query, &database).unwrap();
 
             assert_eq!(similarities.len(), 3);
-            assert!((similarities[0] - 1.0).abs() < 0.001, "Same direction should be 1.0");
+            assert!(
+                (similarities[0] - 1.0).abs() < 0.001,
+                "Same direction should be 1.0"
+            );
             assert!(similarities[1].abs() < 0.001, "Perpendicular should be 0.0");
-            assert!((similarities[2] + 1.0).abs() < 0.001, "Opposite should be -1.0");
+            assert!(
+                (similarities[2] + 1.0).abs() < 0.001,
+                "Opposite should be -1.0"
+            );
         }
 
         #[test]
@@ -2413,8 +2456,8 @@ mod tests {
 
             let query = vec![1.0, 2.0, 3.0, 4.0];
             let database = vec![
-                vec![1.0, 1.0, 1.0, 1.0],  // Sum = 10
-                vec![2.0, 2.0, 2.0, 2.0],  // Sum = 20
+                vec![1.0, 1.0, 1.0, 1.0], // Sum = 10
+                vec![2.0, 2.0, 2.0, 2.0], // Sum = 20
             ];
 
             let products = backend.batch_dot_product(&query, &database).unwrap();
@@ -2430,8 +2473,8 @@ mod tests {
             let backend = MetalBackend::new(&config).unwrap();
 
             let vectors = vec![
-                vec![3.0, 4.0, 0.0, 0.0],  // Magnitude 5
-                vec![1.0, 0.0, 0.0, 0.0],  // Already normalized
+                vec![3.0, 4.0, 0.0, 0.0], // Magnitude 5
+                vec![1.0, 0.0, 0.0, 0.0], // Already normalized
             ];
 
             let normalized = backend.batch_normalize(&vectors).unwrap();
@@ -2447,23 +2490,17 @@ mod tests {
             let config = GpuConfig::default();
             let backend = MetalBackend::new(&config).unwrap();
 
-            let a = vec![
-                vec![1.0, 2.0],
-                vec![3.0, 4.0],
-            ];
-            let b = vec![
-                vec![5.0, 6.0],
-                vec![7.0, 8.0],
-            ];
+            let a = vec![vec![1.0, 2.0], vec![3.0, 4.0]];
+            let b = vec![vec![5.0, 6.0], vec![7.0, 8.0]];
 
             let result = backend.matrix_multiply(&a, &b).unwrap();
 
             assert_eq!(result.len(), 2);
             assert_eq!(result[0].len(), 2);
-            assert!((result[0][0] - 19.0).abs() < 0.001);  // 1*5 + 2*7
-            assert!((result[0][1] - 22.0).abs() < 0.001);  // 1*6 + 2*8
-            assert!((result[1][0] - 43.0).abs() < 0.001);  // 3*5 + 4*7
-            assert!((result[1][1] - 50.0).abs() < 0.001);  // 3*6 + 4*8
+            assert!((result[0][0] - 19.0).abs() < 0.001); // 1*5 + 2*7
+            assert!((result[0][1] - 22.0).abs() < 0.001); // 1*6 + 2*8
+            assert!((result[1][0] - 43.0).abs() < 0.001); // 3*5 + 4*7
+            assert!((result[1][1] - 50.0).abs() < 0.001); // 3*6 + 4*8
         }
 
         #[test]
@@ -2475,7 +2512,7 @@ mod tests {
             let database = vec![
                 vec![0.0, 0.0, 0.0, 0.0],
                 vec![1.0, 1.0, 0.0, 0.0],
-                vec![0.5, 0.5, 0.0, 0.0],  // Exact match
+                vec![0.5, 0.5, 0.0, 0.0], // Exact match
                 vec![10.0, 10.0, 0.0, 0.0],
             ];
 
@@ -2483,7 +2520,7 @@ mod tests {
 
             assert_eq!(indices.len(), 2);
             assert_eq!(distances.len(), 2);
-            assert_eq!(indices[0], 2);  // Exact match should be first
+            assert_eq!(indices[0], 2); // Exact match should be first
             assert!(distances[0] < 0.001);
         }
 
@@ -2498,7 +2535,11 @@ mod tests {
 
             let query: Vec<f32> = (0..dimension).map(|i| i as f32 * 0.01).collect();
             let database: Vec<Vec<f32>> = (0..num_vectors)
-                .map(|i| (0..dimension).map(|j| ((i + j) % 100) as f32 * 0.01).collect())
+                .map(|i| {
+                    (0..dimension)
+                        .map(|j| ((i + j) % 100) as f32 * 0.01)
+                        .collect()
+                })
                 .collect();
 
             let distances = backend.batch_euclidean_distance(&query, &database).unwrap();
@@ -2516,12 +2557,11 @@ mod tests {
             assert_eq!(executor.backend_type(), GpuBackend::Metal);
 
             let query = vec![1.0, 2.0, 3.0];
-            let database = vec![
-                vec![1.0, 2.0, 3.0],
-                vec![4.0, 5.0, 6.0],
-            ];
+            let database = vec![vec![1.0, 2.0, 3.0], vec![4.0, 5.0, 6.0]];
 
-            let distances = executor.batch_euclidean_distance(&query, &database).unwrap();
+            let distances = executor
+                .batch_euclidean_distance(&query, &database)
+                .unwrap();
             assert_eq!(distances.len(), 2);
         }
 
@@ -2551,7 +2591,7 @@ mod tests {
 
             let query = vec![1.0, 2.0, 3.0];
             let mismatched_db = vec![
-                vec![1.0, 2.0],  // Wrong dimension
+                vec![1.0, 2.0], // Wrong dimension
             ];
 
             let result = backend.batch_euclidean_distance(&query, &mismatched_db);
@@ -2594,21 +2634,24 @@ mod tests {
                 Err(_) => {
                     println!("Skipping test: WebGPU not available");
                     return;
-                }
+                },
             };
 
             let query = vec![1.0, 2.0, 3.0, 4.0];
             let database = vec![
-                vec![1.0, 2.0, 3.0, 4.0],  // Same as query
-                vec![2.0, 3.0, 4.0, 5.0],  // Different
-                vec![0.0, 0.0, 0.0, 0.0],  // Origin
+                vec![1.0, 2.0, 3.0, 4.0], // Same as query
+                vec![2.0, 3.0, 4.0, 5.0], // Different
+                vec![0.0, 0.0, 0.0, 0.0], // Origin
             ];
 
             let distances = backend.batch_euclidean_distance(&query, &database).unwrap();
 
             assert_eq!(distances.len(), 3);
             assert!(distances[0] < 0.001, "Same vector should have distance ~0");
-            assert!(distances[1] > 1.0, "Different vector should have larger distance");
+            assert!(
+                distances[1] > 1.0,
+                "Different vector should have larger distance"
+            );
             assert!(distances[2] > 5.0, "Origin should have large distance");
         }
 
@@ -2620,22 +2663,28 @@ mod tests {
                 Err(_) => {
                     println!("Skipping test: WebGPU not available");
                     return;
-                }
+                },
             };
 
             let query = vec![1.0, 0.0, 0.0, 0.0];
             let database = vec![
-                vec![1.0, 0.0, 0.0, 0.0],   // Same direction
-                vec![0.0, 1.0, 0.0, 0.0],   // Perpendicular
-                vec![-1.0, 0.0, 0.0, 0.0],  // Opposite
+                vec![1.0, 0.0, 0.0, 0.0],  // Same direction
+                vec![0.0, 1.0, 0.0, 0.0],  // Perpendicular
+                vec![-1.0, 0.0, 0.0, 0.0], // Opposite
             ];
 
             let similarities = backend.batch_cosine_similarity(&query, &database).unwrap();
 
             assert_eq!(similarities.len(), 3);
-            assert!((similarities[0] - 1.0).abs() < 0.01, "Same direction should be 1.0");
+            assert!(
+                (similarities[0] - 1.0).abs() < 0.01,
+                "Same direction should be 1.0"
+            );
             assert!(similarities[1].abs() < 0.01, "Perpendicular should be 0.0");
-            assert!((similarities[2] + 1.0).abs() < 0.01, "Opposite should be -1.0");
+            assert!(
+                (similarities[2] + 1.0).abs() < 0.01,
+                "Opposite should be -1.0"
+            );
         }
 
         #[test]
@@ -2646,13 +2695,13 @@ mod tests {
                 Err(_) => {
                     println!("Skipping test: WebGPU not available");
                     return;
-                }
+                },
             };
 
             let query = vec![1.0, 2.0, 3.0, 4.0];
             let database = vec![
-                vec![1.0, 1.0, 1.0, 1.0],  // Sum = 10
-                vec![2.0, 2.0, 2.0, 2.0],  // Sum = 20
+                vec![1.0, 1.0, 1.0, 1.0], // Sum = 10
+                vec![2.0, 2.0, 2.0, 2.0], // Sum = 20
             ];
 
             let products = backend.batch_dot_product(&query, &database).unwrap();
@@ -2670,12 +2719,12 @@ mod tests {
                 Err(_) => {
                     println!("Skipping test: WebGPU not available");
                     return;
-                }
+                },
             };
 
             let vectors = vec![
-                vec![3.0, 4.0, 0.0, 0.0],  // Magnitude 5
-                vec![1.0, 0.0, 0.0, 0.0],  // Already normalized
+                vec![3.0, 4.0, 0.0, 0.0], // Magnitude 5
+                vec![1.0, 0.0, 0.0, 0.0], // Already normalized
             ];
 
             let normalized = backend.batch_normalize(&vectors).unwrap();
@@ -2694,14 +2743,14 @@ mod tests {
                 Err(_) => {
                     println!("Skipping test: WebGPU not available");
                     return;
-                }
+                },
             };
 
             let query = vec![0.5, 0.5, 0.0, 0.0];
             let database = vec![
                 vec![0.0, 0.0, 0.0, 0.0],
                 vec![1.0, 1.0, 0.0, 0.0],
-                vec![0.5, 0.5, 0.0, 0.0],  // Exact match
+                vec![0.5, 0.5, 0.0, 0.0], // Exact match
                 vec![10.0, 10.0, 0.0, 0.0],
             ];
 
@@ -2709,7 +2758,7 @@ mod tests {
 
             assert_eq!(indices.len(), 2);
             assert_eq!(distances.len(), 2);
-            assert_eq!(indices[0], 2);  // Exact match should be first
+            assert_eq!(indices[0], 2); // Exact match should be first
             assert!(distances[0] < 0.001);
         }
 
@@ -2721,7 +2770,7 @@ mod tests {
                 Err(_) => {
                     println!("Skipping test: WebGPU not available");
                     return;
-                }
+                },
             };
 
             // Create a large batch to test GPU performance
@@ -2730,7 +2779,11 @@ mod tests {
 
             let query: Vec<f32> = (0..dimension).map(|i| i as f32 * 0.01).collect();
             let database: Vec<Vec<f32>> = (0..num_vectors)
-                .map(|i| (0..dimension).map(|j| ((i + j) % 100) as f32 * 0.01).collect())
+                .map(|i| {
+                    (0..dimension)
+                        .map(|j| ((i + j) % 100) as f32 * 0.01)
+                        .collect()
+                })
                 .collect();
 
             let distances = backend.batch_euclidean_distance(&query, &database).unwrap();
@@ -2748,18 +2801,17 @@ mod tests {
                 Err(_) => {
                     println!("Skipping test: WebGPU not available");
                     return;
-                }
+                },
             };
 
             assert_eq!(executor.backend_type(), GpuBackend::WebGpu);
 
             let query = vec![1.0, 2.0, 3.0];
-            let database = vec![
-                vec![1.0, 2.0, 3.0],
-                vec![4.0, 5.0, 6.0],
-            ];
+            let database = vec![vec![1.0, 2.0, 3.0], vec![4.0, 5.0, 6.0]];
 
-            let distances = executor.batch_euclidean_distance(&query, &database).unwrap();
+            let distances = executor
+                .batch_euclidean_distance(&query, &database)
+                .unwrap();
             assert_eq!(distances.len(), 2);
         }
 
@@ -2771,7 +2823,7 @@ mod tests {
                 Err(_) => {
                     println!("Skipping test: WebGPU not available");
                     return;
-                }
+                },
             };
 
             // Empty database should return empty results
@@ -2796,12 +2848,12 @@ mod tests {
                 Err(_) => {
                     println!("Skipping test: WebGPU not available");
                     return;
-                }
+                },
             };
 
             let query = vec![1.0, 2.0, 3.0];
             let mismatched_db = vec![
-                vec![1.0, 2.0],  // Wrong dimension
+                vec![1.0, 2.0], // Wrong dimension
             ];
 
             let result = backend.batch_euclidean_distance(&query, &mismatched_db);
diff --git a/src/gpu/cuda_kernels.rs b/src/gpu/cuda_kernels.rs
index 91e290a..f37fb5e 100644
--- a/src/gpu/cuda_kernels.rs
+++ b/src/gpu/cuda_kernels.rs
@@ -3,7 +3,6 @@
 //! This module provides CUDA kernel implementations for distance calculations
 //! and other vector operations.
 
-
 /// CUDA kernel source for Euclidean distance
 pub const EUCLIDEAN_DISTANCE_KERNEL: &str = r#"
 extern "C" __global__ void euclidean_distance_kernel(
@@ -366,11 +365,17 @@ END:
             .map_err(|e| anyhow!("Failed to initialize CUDA device {}: {}", device_id, e))?;
 
         // Load PTX module
-        device.load_ptx(
-            cudarc::nvrtc::Ptx::from_src(Self::DISTANCE_PTX),
-            "distance_kernels",
-            &["euclidean_distance_kernel", "cosine_similarity_kernel", "dot_product_kernel"],
-        ).map_err(|e| anyhow!("Failed to load PTX: {}", e))?;
+        device
+            .load_ptx(
+                cudarc::nvrtc::Ptx::from_src(Self::DISTANCE_PTX),
+                "distance_kernels",
+                &[
+                    "euclidean_distance_kernel",
+                    "cosine_similarity_kernel",
+                    "dot_product_kernel",
+                ],
+            )
+            .map_err(|e| anyhow!("Failed to load PTX: {}", e))?;
 
         let euclidean_kernel = device
             .get_func("distance_kernels", "euclidean_distance_kernel")
@@ -404,13 +409,19 @@ END:
         use cudarc::driver::LaunchConfig;
 
         // Copy data to device
-        let query_dev = self.device.htod_sync_copy(query)
+        let query_dev = self
+            .device
+            .htod_sync_copy(query)
             .map_err(|e| anyhow!("Failed to copy query to device: {}", e))?;
-        let database_dev = self.device.htod_sync_copy(database)
+        let database_dev = self
+            .device
+            .htod_sync_copy(database)
             .map_err(|e| anyhow!("Failed to copy database to device: {}", e))?;
 
         // Allocate output buffer
-        let mut distances_dev = self.device.alloc_zeros::<f32>(num_vectors)
+        let mut distances_dev = self
+            .device
+            .alloc_zeros::<f32>(num_vectors)
             .map_err(|e| anyhow!("Failed to allocate output buffer: {}", e))?;
 
         // Configure launch
@@ -424,14 +435,25 @@ END:
 
         // Launch kernel
         unsafe {
-            self.euclidean_kernel.clone().launch(
-                cfg,
-                (&query_dev, &database_dev, &mut distances_dev, num_vectors as u32, vector_dim as u32),
-            ).map_err(|e| anyhow!("Kernel launch failed: {}", e))?;
+            self.euclidean_kernel
+                .clone()
+                .launch(
+                    cfg,
+                    (
+                        &query_dev,
+                        &database_dev,
+                        &mut distances_dev,
+                        num_vectors as u32,
+                        vector_dim as u32,
+                    ),
+                )
+                .map_err(|e| anyhow!("Kernel launch failed: {}", e))?;
         }
 
         // Copy results back
-        let distances = self.device.dtoh_sync_copy(&distances_dev)
+        let distances = self
+            .device
+            .dtoh_sync_copy(&distances_dev)
             .map_err(|e| anyhow!("Failed to copy results from device: {}", e))?;
 
         Ok(distances)
@@ -448,12 +470,18 @@ END:
         use cudarc::driver::LaunchAsync;
         use cudarc::driver::LaunchConfig;
 
-        let query_dev = self.device.htod_sync_copy(query)
+        let query_dev = self
+            .device
+            .htod_sync_copy(query)
             .map_err(|e| anyhow!("Failed to copy query: {}", e))?;
-        let database_dev = self.device.htod_sync_copy(database)
+        let database_dev = self
+            .device
+            .htod_sync_copy(database)
             .map_err(|e| anyhow!("Failed to copy database: {}", e))?;
 
-        let mut similarities_dev = self.device.alloc_zeros::<f32>(num_vectors)
+        let mut similarities_dev = self
+            .device
+            .alloc_zeros::<f32>(num_vectors)
             .map_err(|e| anyhow!("Failed to allocate output: {}", e))?;
 
         let threads_per_block = 256u32;
@@ -465,13 +493,24 @@ END:
         };
 
         unsafe {
-            self.cosine_kernel.clone().launch(
-                cfg,
-                (&query_dev, &database_dev, &mut similarities_dev, num_vectors as u32, vector_dim as u32),
-            ).map_err(|e| anyhow!("Kernel launch failed: {}", e))?;
+            self.cosine_kernel
+                .clone()
+                .launch(
+                    cfg,
+                    (
+                        &query_dev,
+                        &database_dev,
+                        &mut similarities_dev,
+                        num_vectors as u32,
+                        vector_dim as u32,
+                    ),
+                )
+                .map_err(|e| anyhow!("Kernel launch failed: {}", e))?;
         }
 
-        let similarities = self.device.dtoh_sync_copy(&similarities_dev)
+        let similarities = self
+            .device
+            .dtoh_sync_copy(&similarities_dev)
             .map_err(|e| anyhow!("Failed to copy results: {}", e))?;
 
         Ok(similarities)
@@ -488,12 +527,18 @@ END:
         use cudarc::driver::LaunchAsync;
         use cudarc::driver::LaunchConfig;
 
-        let query_dev = self.device.htod_sync_copy(query)
+        let query_dev = self
+            .device
+            .htod_sync_copy(query)
             .map_err(|e| anyhow!("Failed to copy query: {}", e))?;
-        let database_dev = self.device.htod_sync_copy(database)
+        let database_dev = self
+            .device
+            .htod_sync_copy(database)
             .map_err(|e| anyhow!("Failed to copy database: {}", e))?;
 
-        let mut products_dev = self.device.alloc_zeros::<f32>(num_vectors)
+        let mut products_dev = self
+            .device
+            .alloc_zeros::<f32>(num_vectors)
             .map_err(|e| anyhow!("Failed to allocate output: {}", e))?;
 
         let threads_per_block = 256u32;
@@ -505,13 +550,24 @@ END:
         };
 
         unsafe {
-            self.dot_kernel.clone().launch(
-                cfg,
-                (&query_dev, &database_dev, &mut products_dev, num_vectors as u32, vector_dim as u32),
-            ).map_err(|e| anyhow!("Kernel launch failed: {}", e))?;
+            self.dot_kernel
+                .clone()
+                .launch(
+                    cfg,
+                    (
+                        &query_dev,
+                        &database_dev,
+                        &mut products_dev,
+                        num_vectors as u32,
+                        vector_dim as u32,
+                    ),
+                )
+                .map_err(|e| anyhow!("Kernel launch failed: {}", e))?;
         }
 
-        let products = self.device.dtoh_sync_copy(&products_dev)
+        let products = self
+            .device
+            .dtoh_sync_copy(&products_dev)
             .map_err(|e| anyhow!("Failed to copy results: {}", e))?;
 
         Ok(products)
diff --git a/src/gpu/metal_executor.rs b/src/gpu/metal_executor.rs
index 8c2288e..1575591 100644
--- a/src/gpu/metal_executor.rs
+++ b/src/gpu/metal_executor.rs
@@ -258,7 +258,9 @@ mod tests {
         let query = vec![1.0, 0.0];
         let database = vec![0.0, 0.0, 1.0, 1.0];
 
-        let distances = executor.euclidean_distance(&query, &database, 2, 2).unwrap();
+        let distances = executor
+            .euclidean_distance(&query, &database, 2, 2)
+            .unwrap();
 
         assert_eq!(distances.len(), 2);
         assert!((distances[0] - 1.0).abs() < 1e-6); // distance to [0, 0] is 1
diff --git a/src/gpu_indexing.rs b/src/gpu_indexing.rs
index ee085bb..eecdaa8 100644
--- a/src/gpu_indexing.rs
+++ b/src/gpu_indexing.rs
@@ -31,7 +31,10 @@
 //! ```
 
 use std::collections::HashMap;
-use std::sync::{RwLock, atomic::{AtomicUsize, Ordering}};
+use std::sync::{
+    RwLock,
+    atomic::{AtomicUsize, Ordering},
+};
 use std::time::{Duration, Instant};
 
 use serde::{Deserialize, Serialize};
@@ -229,8 +232,11 @@ impl MemoryPool {
     fn allocate(&self, size: usize) -> Result<usize> {
         // Try to reuse existing buffer
         {
-            let mut buffers = self.buffers.write()
-                .map_err(|_| VecStoreError::LockError("failed to acquire write lock on GPU memory pool buffers".into()))?;
+            let mut buffers = self.buffers.write().map_err(|_| {
+                VecStoreError::LockError(
+                    "failed to acquire write lock on GPU memory pool buffers".into(),
+                )
+            })?;
             for buffer in &mut *buffers {
                 if !buffer.in_use && buffer.size >= size {
                     buffer.in_use = true;
@@ -255,15 +261,20 @@ impl MemoryPool {
             in_use: true,
         };
 
-        let mut buffers = self.buffers.write()
-            .map_err(|_| VecStoreError::LockError("failed to acquire write lock on GPU memory pool buffers for allocation".into()))?;
+        let mut buffers = self.buffers.write().map_err(|_| {
+            VecStoreError::LockError(
+                "failed to acquire write lock on GPU memory pool buffers for allocation".into(),
+            )
+        })?;
         buffers.push(buffer);
 
         Ok(id)
     }
 
     fn free(&self, id: usize) {
-        let Ok(mut buffers) = self.buffers.write() else { return; };
+        let Ok(mut buffers) = self.buffers.write() else {
+            return;
+        };
         for buffer in &mut *buffers {
             if buffer.id == id {
                 buffer.in_use = false;
@@ -342,9 +353,15 @@ impl GpuHnswIndex {
         results
     }
 
-    fn search_layer(&self, query: &[f32], entry: usize, ef: usize, layer: usize) -> Vec<(usize, f32)> {
-        use std::collections::{BinaryHeap, HashSet};
+    fn search_layer(
+        &self,
+        query: &[f32],
+        entry: usize,
+        ef: usize,
+        layer: usize,
+    ) -> Vec<(usize, f32)> {
         use std::cmp::Ordering;
+        use std::collections::{BinaryHeap, HashSet};
 
         #[derive(Clone)]
         struct Candidate {
@@ -378,8 +395,14 @@ impl GpuHnswIndex {
         let mut results: BinaryHeap<Candidate> = BinaryHeap::new();
 
         let entry_dist = self.distance(query, entry);
-        candidates.push(Candidate { id: entry, distance: entry_dist });
-        results.push(Candidate { id: entry, distance: entry_dist });
+        candidates.push(Candidate {
+            id: entry,
+            distance: entry_dist,
+        });
+        results.push(Candidate {
+            id: entry,
+            distance: entry_dist,
+        });
         visited.insert(entry);
 
         while let Some(current) = candidates.pop() {
@@ -399,8 +422,14 @@ impl GpuHnswIndex {
                     let dist = self.distance(query, neighbor);
 
                     if dist < worst_result || results.len() < ef {
-                        candidates.push(Candidate { id: neighbor, distance: dist });
-                        results.push(Candidate { id: neighbor, distance: dist });
+                        candidates.push(Candidate {
+                            id: neighbor,
+                            distance: dist,
+                        });
+                        results.push(Candidate {
+                            id: neighbor,
+                            distance: dist,
+                        });
 
                         while results.len() > ef {
                             results.pop();
@@ -410,7 +439,8 @@ impl GpuHnswIndex {
             }
         }
 
-        results.into_sorted_vec()
+        results
+            .into_sorted_vec()
             .into_iter()
             .map(|c| (c.id, c.distance))
             .collect()
@@ -418,18 +448,10 @@ impl GpuHnswIndex {
 
     fn distance(&self, query: &[f32], idx: usize) -> f32 {
         match self.params.metric {
-            GpuDistanceMetric::Cosine => {
-                1.0 - cosine_similarity(query, &self.vectors[idx])
-            }
-            GpuDistanceMetric::Euclidean => {
-                euclidean_distance(query, &self.vectors[idx])
-            }
-            GpuDistanceMetric::DotProduct => {
-                -dot_product(query, &self.vectors[idx])
-            }
-            GpuDistanceMetric::Manhattan => {
-                manhattan_distance(query, &self.vectors[idx])
-            }
+            GpuDistanceMetric::Cosine => 1.0 - cosine_similarity(query, &self.vectors[idx]),
+            GpuDistanceMetric::Euclidean => euclidean_distance(query, &self.vectors[idx]),
+            GpuDistanceMetric::DotProduct => -dot_product(query, &self.vectors[idx]),
+            GpuDistanceMetric::Manhattan => manhattan_distance(query, &self.vectors[idx]),
         }
     }
 
@@ -440,7 +462,9 @@ impl GpuHnswIndex {
 
     /// Get index statistics
     pub fn stats(&self) -> GpuIndexStats {
-        let total_edges: usize = self.layers.iter()
+        let total_edges: usize = self
+            .layers
+            .iter()
             .flat_map(|l| l.values())
             .map(|neighbors| neighbors.len())
             .sum();
@@ -562,7 +586,8 @@ impl GpuIndexBuilder {
         }
 
         // Entry point is the node with the highest layer
-        let entry_point = node_layers.iter()
+        let entry_point = node_layers
+            .iter()
             .enumerate()
             .max_by_key(|(_, l)| **l)
             .map(|(i, _)| i);
@@ -576,9 +601,8 @@ impl GpuIndexBuilder {
             #[allow(clippy::needless_range_loop)]
             for layer in 0..=node_max_layer {
                 // Find neighbors at this layer
-                let nodes_at_layer: Vec<usize> = (0..i)
-                    .filter(|&j| node_layers[j] >= layer)
-                    .collect();
+                let nodes_at_layer: Vec<usize> =
+                    (0..i).filter(|&j| node_layers[j] >= layer).collect();
 
                 if nodes_at_layer.is_empty() {
                     continue;
@@ -589,10 +613,16 @@ impl GpuIndexBuilder {
                     .iter()
                     .map(|&j| {
                         let d = match params.metric {
-                            GpuDistanceMetric::Cosine => 1.0 - cosine_similarity(&vectors[i], &vectors[j]),
-                            GpuDistanceMetric::Euclidean => euclidean_distance(&vectors[i], &vectors[j]),
+                            GpuDistanceMetric::Cosine => {
+                                1.0 - cosine_similarity(&vectors[i], &vectors[j])
+                            },
+                            GpuDistanceMetric::Euclidean => {
+                                euclidean_distance(&vectors[i], &vectors[j])
+                            },
                             GpuDistanceMetric::DotProduct => -dot_product(&vectors[i], &vectors[j]),
-                            GpuDistanceMetric::Manhattan => manhattan_distance(&vectors[i], &vectors[j]),
+                            GpuDistanceMetric::Manhattan => {
+                                manhattan_distance(&vectors[i], &vectors[j])
+                            },
                         };
                         (j, d)
                     })
@@ -601,10 +631,8 @@ impl GpuIndexBuilder {
                 distances.sort_by(|a, b| a.1.total_cmp(&b.1));
 
                 // Keep M neighbors
-                let neighbors: Vec<usize> = distances.iter()
-                    .take(params.m)
-                    .map(|(j, _)| *j)
-                    .collect();
+                let neighbors: Vec<usize> =
+                    distances.iter().take(params.m).map(|(j, _)| *j).collect();
 
                 // Add bidirectional edges
                 layers[layer].insert(i, neighbors.clone());
@@ -650,18 +678,23 @@ impl GpuIndexBuilder {
     }
 
     /// Compute batch distances on GPU
-    pub fn batch_distances(&self, queries: &[Vec<f32>], database: &[Vec<f32>], metric: GpuDistanceMetric) -> Vec<Vec<f32>> {
+    pub fn batch_distances(
+        &self,
+        queries: &[Vec<f32>],
+        database: &[Vec<f32>],
+        metric: GpuDistanceMetric,
+    ) -> Vec<Vec<f32>> {
         // In production, this would run on GPU
-        queries.iter()
+        queries
+            .iter()
             .map(|query| {
-                database.iter()
-                    .map(|doc| {
-                        match metric {
-                            GpuDistanceMetric::Cosine => 1.0 - cosine_similarity(query, doc),
-                            GpuDistanceMetric::Euclidean => euclidean_distance(query, doc),
-                            GpuDistanceMetric::DotProduct => -dot_product(query, doc),
-                            GpuDistanceMetric::Manhattan => manhattan_distance(query, doc),
-                        }
+                database
+                    .iter()
+                    .map(|doc| match metric {
+                        GpuDistanceMetric::Cosine => 1.0 - cosine_similarity(query, doc),
+                        GpuDistanceMetric::Euclidean => euclidean_distance(query, doc),
+                        GpuDistanceMetric::DotProduct => -dot_product(query, doc),
+                        GpuDistanceMetric::Manhattan => manhattan_distance(query, doc),
                     })
                     .collect()
             })
@@ -676,18 +709,16 @@ impl GpuIndexBuilder {
     /// Get available GPU devices
     pub fn available_devices() -> Vec<GpuDeviceInfo> {
         // In production, would actually enumerate devices
-        vec![
-            GpuDeviceInfo {
-                index: 0,
-                name: "CPU (Fallback)".to_string(),
-                backend: GpuBackendType::CPU,
-                memory_bytes: 16 * 1024 * 1024 * 1024, // 16GB
-                available_memory_bytes: 8 * 1024 * 1024 * 1024,
-                compute_capability: None,
-                max_work_group_size: 1024,
-                max_shared_memory: 48 * 1024,
-            }
-        ]
+        vec![GpuDeviceInfo {
+            index: 0,
+            name: "CPU (Fallback)".to_string(),
+            backend: GpuBackendType::CPU,
+            memory_bytes: 16 * 1024 * 1024 * 1024, // 16GB
+            available_memory_bytes: 8 * 1024 * 1024 * 1024,
+            compute_capability: None,
+            max_work_group_size: 1024,
+            max_shared_memory: 48 * 1024,
+        }]
     }
 }
 
@@ -753,9 +784,7 @@ mod tests {
         let builder = GpuIndexBuilder::new(config);
 
         let vectors: Vec<Vec<f32>> = (0..100)
-            .map(|i| {
-                (0..64).map(|j| ((i + j) as f32) / 100.0).collect()
-            })
+            .map(|i| (0..64).map(|j| ((i + j) as f32) / 100.0).collect())
             .collect();
 
         let params = HnswParams {
@@ -777,11 +806,7 @@ mod tests {
         let config = GpuConfig::default();
         let builder = GpuIndexBuilder::new(config);
 
-        let vectors: Vec<Vec<f32>> = (0..50)
-            .map(|i| {
-                vec![i as f32 / 50.0; 32]
-            })
-            .collect();
+        let vectors: Vec<Vec<f32>> = (0..50).map(|i| vec![i as f32 / 50.0; 32]).collect();
 
         let params = HnswParams::default();
         let index = builder.build_hnsw(&vectors, params).unwrap();
@@ -799,10 +824,7 @@ mod tests {
         let config = GpuConfig::default();
         let builder = GpuIndexBuilder::new(config);
 
-        let queries = vec![
-            vec![1.0, 0.0, 0.0],
-            vec![0.0, 1.0, 0.0],
-        ];
+        let queries = vec![vec![1.0, 0.0, 0.0], vec![0.0, 1.0, 0.0]];
 
         let database = vec![
             vec![1.0, 0.0, 0.0],
@@ -831,9 +853,7 @@ mod tests {
         let config = GpuConfig::default();
         let builder = GpuIndexBuilder::new(config);
 
-        let vectors: Vec<Vec<f32>> = (0..20)
-            .map(|i| vec![i as f32; 16])
-            .collect();
+        let vectors: Vec<Vec<f32>> = (0..20).map(|i| vec![i as f32; 16]).collect();
 
         let index = builder.build_hnsw(&vectors, HnswParams::default()).unwrap();
         let stats = index.build_stats();
diff --git a/src/graph_rag.rs b/src/graph_rag.rs
index ca92a06..060c58d 100644
--- a/src/graph_rag.rs
+++ b/src/graph_rag.rs
@@ -63,7 +63,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet, VecDeque};
 
@@ -330,10 +330,7 @@ impl GraphRAG {
             .push(relation.clone());
 
         // Add to incoming edges
-        self.incoming
-            .entry(to)
-            .or_default()
-            .push(relation);
+        self.incoming.entry(to).or_default().push(relation);
 
         Ok(())
     }
@@ -358,10 +355,7 @@ impl GraphRAG {
             .push(relation.clone());
 
         // Add to incoming edges
-        self.incoming
-            .entry(to)
-            .or_default()
-            .push(relation);
+        self.incoming.entry(to).or_default().push(relation);
 
         Ok(())
     }
@@ -456,9 +450,10 @@ impl GraphRAG {
                     }
 
                     if let Some(ref filter) = query.relation_type_filter
-                        && !filter.contains(&relation.relation_type) {
-                            continue;
-                        }
+                        && !filter.contains(&relation.relation_type)
+                    {
+                        continue;
+                    }
 
                     if !visited.contains(&relation.to) {
                         subgraph.push(relation.to.clone());
diff --git a/src/graph_vector.rs b/src/graph_vector.rs
index 46c645f..bad6ddd 100644
--- a/src/graph_vector.rs
+++ b/src/graph_vector.rs
@@ -36,9 +36,9 @@
 //! )?;
 //! ```
 
-use std::collections::{HashMap, HashSet, BinaryHeap};
-use std::cmp::Ordering;
 use serde::{Deserialize, Serialize};
+use std::cmp::Ordering;
+use std::collections::{BinaryHeap, HashMap, HashSet};
 
 use crate::error::VecStoreError;
 
@@ -289,7 +289,8 @@ impl GraphVectorEngine {
 
         if self.nodes.contains_key(&id) {
             return Err(VecStoreError::InvalidInput(format!(
-                "Node {} already exists", id
+                "Node {} already exists",
+                id
             )));
         }
 
@@ -319,19 +320,24 @@ impl GraphVectorEngine {
         // Validate nodes exist
         if !self.nodes.contains_key(&edge.from) {
             return Err(VecStoreError::NotFound(format!(
-                "Source node {} not found", edge.from
+                "Source node {} not found",
+                edge.from
             )));
         }
         if !self.nodes.contains_key(&edge.to) {
             return Err(VecStoreError::NotFound(format!(
-                "Target node {} not found", edge.to
+                "Target node {} not found",
+                edge.to
             )));
         }
 
         let edge_idx = self.edges.len();
 
         // Update adjacency lists
-        self.adjacency_out.get_mut(&edge.from).unwrap().push(edge_idx);
+        self.adjacency_out
+            .get_mut(&edge.from)
+            .unwrap()
+            .push(edge_idx);
         self.adjacency_in.get_mut(&edge.to).unwrap().push(edge_idx);
 
         // Update node references
@@ -387,9 +393,10 @@ impl GraphVectorEngine {
         while let Some(current) = heap.pop() {
             // Skip if we've seen this node with a better score
             if let Some(existing) = visited.get(&current.node_id)
-                && existing.score >= current.score {
-                    continue;
-                }
+                && existing.score >= current.score
+            {
+                continue;
+            }
 
             // Get node info
             let node = match self.nodes.get(&current.node_id) {
@@ -401,8 +408,8 @@ impl GraphVectorEngine {
             let vector_score = self.cosine_similarity(query_vector, &node.vector);
 
             // Combined score
-            let combined_score = vector_score * config.vector_weight
-                + current.score * config.edge_weight;
+            let combined_score =
+                vector_score * config.vector_weight + current.score * config.edge_weight;
 
             if combined_score < config.min_score {
                 continue;
@@ -430,8 +437,7 @@ impl GraphVectorEngine {
                     let edge = &self.edges[edge_idx];
 
                     // Check edge type filter
-                    if !config.edge_types.is_empty()
-                        && !config.edge_types.contains(&edge.edge_type)
+                    if !config.edge_types.is_empty() && !config.edge_types.contains(&edge.edge_type)
                     {
                         continue;
                     }
@@ -469,7 +475,8 @@ impl GraphVectorEngine {
         }
 
         // Filter and sort results
-        let mut results: Vec<GraphSearchResult> = visited.into_values()
+        let mut results: Vec<GraphSearchResult> = visited
+            .into_values()
             .filter(|r| config.include_start || r.hops > 0)
             .filter(|r| r.score >= config.min_score)
             .collect();
@@ -489,7 +496,8 @@ impl GraphVectorEngine {
     ) -> Result<Vec<(String, usize)>, VecStoreError> {
         if !self.nodes.contains_key(start_id) {
             return Err(VecStoreError::NotFound(format!(
-                "Node {} not found", start_id
+                "Node {} not found",
+                start_id
             )));
         }
 
@@ -527,7 +535,11 @@ impl GraphVectorEngine {
     }
 
     /// Find the shortest path between two nodes
-    pub fn shortest_path(&self, from: &str, to: &str) -> Result<Option<Vec<String>>, VecStoreError> {
+    pub fn shortest_path(
+        &self,
+        from: &str,
+        to: &str,
+    ) -> Result<Option<Vec<String>>, VecStoreError> {
         if !self.nodes.contains_key(from) {
             return Err(VecStoreError::NotFound(format!("Node {} not found", from)));
         }
@@ -587,7 +599,10 @@ impl GraphVectorEngine {
         direction: TraversalDirection,
     ) -> Result<Vec<(String, EdgeType, f32)>, VecStoreError> {
         if !self.nodes.contains_key(node_id) {
-            return Err(VecStoreError::NotFound(format!("Node {} not found", node_id)));
+            return Err(VecStoreError::NotFound(format!(
+                "Node {} not found",
+                node_id
+            )));
         }
 
         let edges = self.get_edges_for_traversal(node_id, &direction);
@@ -601,11 +616,7 @@ impl GraphVectorEngine {
                 &edge.from
             };
 
-            neighbors.push((
-                neighbor_id.clone(),
-                edge.edge_type.clone(),
-                edge.weight,
-            ));
+            neighbors.push((neighbor_id.clone(), edge.edge_type.clone(), edge.weight));
         }
 
         Ok(neighbors)
@@ -668,7 +679,9 @@ impl GraphVectorEngine {
         }
 
         // Mark edges for removal (edges involving this node)
-        let edges_to_remove: Vec<usize> = self.edges.iter()
+        let edges_to_remove: Vec<usize> = self
+            .edges
+            .iter()
             .enumerate()
             .filter(|(_, e)| e.from == id || e.to == id)
             .map(|(i, _)| i)
@@ -692,9 +705,10 @@ impl GraphVectorEngine {
 
     /// Update node vector
     pub fn update_vector(&mut self, id: &str, new_vector: Vec<f32>) -> Result<(), VecStoreError> {
-        let node = self.nodes.get_mut(id).ok_or_else(|| {
-            VecStoreError::NotFound(format!("Node {} not found", id))
-        })?;
+        let node = self
+            .nodes
+            .get_mut(id)
+            .ok_or_else(|| VecStoreError::NotFound(format!("Node {} not found", id)))?;
 
         node.vector = new_vector;
         Ok(())
@@ -708,7 +722,9 @@ impl GraphVectorEngine {
     // === Helper Methods ===
 
     fn find_similar_nodes(&self, query: &[f32], limit: usize) -> Vec<(String, f32)> {
-        let mut scores: Vec<_> = self.nodes.iter()
+        let mut scores: Vec<_> = self
+            .nodes
+            .iter()
             .map(|(id, node)| {
                 let sim = self.cosine_similarity(query, &node.vector);
                 (id.clone(), sim)
@@ -728,12 +744,12 @@ impl GraphVectorEngine {
                 if let Some(out_edges) = self.adjacency_out.get(node_id) {
                     edges.extend(out_edges);
                 }
-            }
+            },
             TraversalDirection::Incoming => {
                 if let Some(in_edges) = self.adjacency_in.get(node_id) {
                     edges.extend(in_edges);
                 }
-            }
+            },
             TraversalDirection::Both => {
                 if let Some(out_edges) = self.adjacency_out.get(node_id) {
                     edges.extend(out_edges);
@@ -741,7 +757,7 @@ impl GraphVectorEngine {
                 if let Some(in_edges) = self.adjacency_in.get(node_id) {
                     edges.extend(in_edges);
                 }
-            }
+            },
         }
 
         edges
@@ -900,15 +916,29 @@ mod tests {
         let mut engine = GraphVectorEngine::new();
 
         // Add nodes
-        engine.add_node(GraphNode::new("a", vec![1.0, 0.0, 0.0])).unwrap();
-        engine.add_node(GraphNode::new("b", vec![0.9, 0.1, 0.0])).unwrap();
-        engine.add_node(GraphNode::new("c", vec![0.0, 1.0, 0.0])).unwrap();
-        engine.add_node(GraphNode::new("d", vec![0.0, 0.0, 1.0])).unwrap();
+        engine
+            .add_node(GraphNode::new("a", vec![1.0, 0.0, 0.0]))
+            .unwrap();
+        engine
+            .add_node(GraphNode::new("b", vec![0.9, 0.1, 0.0]))
+            .unwrap();
+        engine
+            .add_node(GraphNode::new("c", vec![0.0, 1.0, 0.0]))
+            .unwrap();
+        engine
+            .add_node(GraphNode::new("d", vec![0.0, 0.0, 1.0]))
+            .unwrap();
 
         // Add edges: a -> b -> c, a -> d
-        engine.add_edge_simple("a", "b", EdgeType::References, 1.0).unwrap();
-        engine.add_edge_simple("b", "c", EdgeType::References, 0.8).unwrap();
-        engine.add_edge_simple("a", "d", EdgeType::RelatedTo, 0.5).unwrap();
+        engine
+            .add_edge_simple("a", "b", EdgeType::References, 1.0)
+            .unwrap();
+        engine
+            .add_edge_simple("b", "c", EdgeType::References, 0.8)
+            .unwrap();
+        engine
+            .add_edge_simple("a", "d", EdgeType::RelatedTo, 0.5)
+            .unwrap();
 
         engine
     }
@@ -929,7 +959,9 @@ mod tests {
     fn test_get_neighbors() {
         let engine = create_test_graph();
 
-        let neighbors = engine.get_neighbors("a", TraversalDirection::Outgoing).unwrap();
+        let neighbors = engine
+            .get_neighbors("a", TraversalDirection::Outgoing)
+            .unwrap();
         assert_eq!(neighbors.len(), 2);
 
         let neighbor_ids: Vec<_> = neighbors.iter().map(|(id, _, _)| id.as_str()).collect();
@@ -941,7 +973,9 @@ mod tests {
     fn test_find_reachable() {
         let engine = create_test_graph();
 
-        let reachable = engine.find_reachable("a", 2, TraversalDirection::Outgoing).unwrap();
+        let reachable = engine
+            .find_reachable("a", 2, TraversalDirection::Outgoing)
+            .unwrap();
 
         // Should find a (0 hops), b and d (1 hop), c (2 hops)
         assert_eq!(reachable.len(), 4);
@@ -990,14 +1024,26 @@ mod tests {
         let mut engine = GraphVectorEngine::new();
 
         // Component 1: a - b
-        engine.add_node(GraphNode::new("a", vec![1.0, 0.0])).unwrap();
-        engine.add_node(GraphNode::new("b", vec![0.0, 1.0])).unwrap();
-        engine.add_edge_simple("a", "b", EdgeType::RelatedTo, 1.0).unwrap();
+        engine
+            .add_node(GraphNode::new("a", vec![1.0, 0.0]))
+            .unwrap();
+        engine
+            .add_node(GraphNode::new("b", vec![0.0, 1.0]))
+            .unwrap();
+        engine
+            .add_edge_simple("a", "b", EdgeType::RelatedTo, 1.0)
+            .unwrap();
 
         // Component 2: c - d (disconnected)
-        engine.add_node(GraphNode::new("c", vec![0.5, 0.5])).unwrap();
-        engine.add_node(GraphNode::new("d", vec![0.5, 0.5])).unwrap();
-        engine.add_edge_simple("c", "d", EdgeType::RelatedTo, 1.0).unwrap();
+        engine
+            .add_node(GraphNode::new("c", vec![0.5, 0.5]))
+            .unwrap();
+        engine
+            .add_node(GraphNode::new("d", vec![0.5, 0.5]))
+            .unwrap();
+        engine
+            .add_edge_simple("c", "d", EdgeType::RelatedTo, 1.0)
+            .unwrap();
 
         let stats = engine.stats();
         assert_eq!(stats.component_count, 2);
diff --git a/src/graphql_api.rs b/src/graphql_api.rs
index 4067b55..c7ba948 100644
--- a/src/graphql_api.rs
+++ b/src/graphql_api.rs
@@ -32,11 +32,11 @@
 //! }
 //! ```
 
-use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
+use std::collections::HashMap;
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 // ============================================================================
 // SCHEMA TYPES
@@ -94,10 +94,17 @@ impl GqlCollection {
     pub fn to_sdl(&self) -> String {
         let mut sdl = format!("type {} {{\n", self.name);
         for field in &self.fields {
-            let desc = field.description.as_ref()
+            let desc = field
+                .description
+                .as_ref()
                 .map(|d| format!("  \"{}\"\n", d))
                 .unwrap_or_default();
-            sdl.push_str(&format!("{}  {}: {}\n", desc, field.name, field.field_type.to_sdl()));
+            sdl.push_str(&format!(
+                "{}  {}: {}\n",
+                desc,
+                field.name,
+                field.field_type.to_sdl()
+            ));
         }
         sdl.push_str("  _additional: _Additional\n");
         sdl.push_str("}\n");
@@ -257,7 +264,9 @@ impl GraphQLExecutor {
         vector: Vec<f32>,
         properties: HashMap<String, JsonValue>,
     ) -> Result<()> {
-        let col = self.collections.get(collection)
+        let col = self
+            .collections
+            .get(collection)
             .ok_or_else(|| VecStoreError::NotFound(format!("Collection: {}", collection)))?;
 
         if vector.len() != col.dimension {
@@ -277,7 +286,9 @@ impl GraphQLExecutor {
 
     /// Execute a vector query
     pub fn execute(&self, query: VectorQuery) -> Result<QueryResult> {
-        let _collection = self.collections.get(&query.collection)
+        let _collection = self
+            .collections
+            .get(&query.collection)
             .ok_or_else(|| VecStoreError::NotFound(format!("Collection: {}", query.collection)))?;
 
         let vectors = self.vectors.get(&query.collection).unwrap();
@@ -288,13 +299,14 @@ impl GraphQLExecutor {
         if let Some(near_vector) = &query.near_vector {
             for (id, (vec, props)) in vectors {
                 let similarity = cosine_similarity(&near_vector.vector, vec);
-                let certainty = (similarity + 1.0) / 2.0;  // Convert to 0-1 range
+                let certainty = (similarity + 1.0) / 2.0; // Convert to 0-1 range
 
                 // Check certainty threshold
                 if let Some(min_cert) = near_vector.certainty
-                    && certainty < min_cert {
-                        continue;
-                    }
+                    && certainty < min_cert
+                {
+                    continue;
+                }
 
                 // Check distance threshold
                 if let Some(max_dist) = near_vector.distance {
@@ -329,7 +341,8 @@ impl GraphQLExecutor {
         results = results.into_iter().skip(offset).take(limit).collect();
 
         // Build result items
-        let items: Vec<QueryResultItem> = results.into_iter()
+        let items: Vec<QueryResultItem> = results
+            .into_iter()
             .map(|(id, score, props)| {
                 let mut properties = HashMap::new();
                 for field in &query.fields {
@@ -348,7 +361,10 @@ impl GraphQLExecutor {
                     explanation: None,
                 };
 
-                QueryResultItem { properties, additional }
+                QueryResultItem {
+                    properties,
+                    additional,
+                }
             })
             .collect();
 
@@ -368,57 +384,53 @@ impl GraphQLExecutor {
                 } else {
                     true
                 }
-            }
+            },
             WhereOperator::Or => {
                 if let Some(operands) = &filter.operands {
                     operands.iter().any(|f| self.evaluate_filter(f, props))
                 } else {
                     false
                 }
-            }
+            },
             WhereOperator::Equal => {
                 if let Some(path) = &filter.path
                     && let Some(field) = path.first()
-                        && let Some(value) = props.get(field) {
-                            return self.compare_equal(value, filter);
-                        }
+                    && let Some(value) = props.get(field)
+                {
+                    return self.compare_equal(value, filter);
+                }
                 false
-            }
+            },
             WhereOperator::NotEqual => {
                 if let Some(path) = &filter.path
                     && let Some(field) = path.first()
-                        && let Some(value) = props.get(field) {
-                            return !self.compare_equal(value, filter);
-                        }
+                    && let Some(value) = props.get(field)
+                {
+                    return !self.compare_equal(value, filter);
+                }
                 true
-            }
-            WhereOperator::GreaterThan => {
-                self.compare_numeric(filter, props, |a, b| a > b)
-            }
-            WhereOperator::GreaterThanEqual => {
-                self.compare_numeric(filter, props, |a, b| a >= b)
-            }
-            WhereOperator::LessThan => {
-                self.compare_numeric(filter, props, |a, b| a < b)
-            }
-            WhereOperator::LessThanEqual => {
-                self.compare_numeric(filter, props, |a, b| a <= b)
-            }
+            },
+            WhereOperator::GreaterThan => self.compare_numeric(filter, props, |a, b| a > b),
+            WhereOperator::GreaterThanEqual => self.compare_numeric(filter, props, |a, b| a >= b),
+            WhereOperator::LessThan => self.compare_numeric(filter, props, |a, b| a < b),
+            WhereOperator::LessThanEqual => self.compare_numeric(filter, props, |a, b| a <= b),
             WhereOperator::Like => {
                 if let (Some(path), Some(pattern)) = (&filter.path, &filter.value_string)
                     && let Some(field) = path.first()
-                        && let Some(JsonValue::String(s)) = props.get(field) {
-                            return self.match_like(s, pattern);
-                        }
+                    && let Some(JsonValue::String(s)) = props.get(field)
+                {
+                    return self.match_like(s, pattern);
+                }
                 false
-            }
+            },
             WhereOperator::IsNull => {
                 if let Some(path) = &filter.path
-                    && let Some(field) = path.first() {
-                        return props.get(field).map(|v| v.is_null()).unwrap_or(true);
-                    }
+                    && let Some(field) = path.first()
+                {
+                    return props.get(field).map(|v| v.is_null()).unwrap_or(true);
+                }
                 false
-            }
+            },
             _ => true,
         }
     }
@@ -439,21 +451,27 @@ impl GraphQLExecutor {
         false
     }
 
-    fn compare_numeric<F>(&self, filter: &WhereFilter, props: &HashMap<String, JsonValue>, cmp: F) -> bool
+    fn compare_numeric<F>(
+        &self,
+        filter: &WhereFilter,
+        props: &HashMap<String, JsonValue>,
+        cmp: F,
+    ) -> bool
     where
         F: Fn(f64, f64) -> bool,
     {
         if let Some(path) = &filter.path
             && let Some(field) = path.first()
-                && let Some(value) = props.get(field)
-                    && let Some(v) = value.as_f64() {
-                        if let Some(n) = filter.value_number {
-                            return cmp(v, n);
-                        }
-                        if let Some(i) = filter.value_int {
-                            return cmp(v, i as f64);
-                        }
-                    }
+            && let Some(value) = props.get(field)
+            && let Some(v) = value.as_f64()
+        {
+            if let Some(n) = filter.value_number {
+                return cmp(v, n);
+            }
+            if let Some(i) = filter.value_int {
+                return cmp(v, i as f64);
+            }
+        }
         false
     }
 
@@ -658,7 +676,8 @@ fn extract_collection(query: &str) -> Result<String> {
         let rest = &query[start..];
         if let Some(brace) = rest.find('{') {
             let after_brace = &rest[brace + 1..];
-            let name: String = after_brace.trim()
+            let name: String = after_brace
+                .trim()
                 .chars()
                 .take_while(|c| c.is_alphanumeric() || *c == '_')
                 .collect();
@@ -667,7 +686,9 @@ fn extract_collection(query: &str) -> Result<String> {
             }
         }
     }
-    Err(VecStoreError::InvalidInput("Could not parse collection name".to_string()))
+    Err(VecStoreError::InvalidInput(
+        "Could not parse collection name".to_string(),
+    ))
 }
 
 fn extract_near_vector(query: &str) -> Option<NearVectorInput> {
@@ -675,19 +696,22 @@ fn extract_near_vector(query: &str) -> Option<NearVectorInput> {
         // Very simplified - would need proper parsing
         if let Some(vec_start) = query[start..].find("vector:")
             && let Some(bracket_start) = query[start + vec_start..].find('[')
-                && let Some(bracket_end) = query[start + vec_start + bracket_start..].find(']') {
-                    let vec_str = &query[start + vec_start + bracket_start + 1..start + vec_start + bracket_start + bracket_end];
-                    let vector: Vec<f32> = vec_str.split(',')
-                        .filter_map(|s| s.trim().parse().ok())
-                        .collect();
-                    if !vector.is_empty() {
-                        return Some(NearVectorInput {
-                            vector,
-                            certainty: extract_float(query, "certainty:"),
-                            distance: extract_float(query, "distance:"),
-                        });
-                    }
-                }
+            && let Some(bracket_end) = query[start + vec_start + bracket_start..].find(']')
+        {
+            let vec_str = &query[start + vec_start + bracket_start + 1
+                ..start + vec_start + bracket_start + bracket_end];
+            let vector: Vec<f32> = vec_str
+                .split(',')
+                .filter_map(|s| s.trim().parse().ok())
+                .collect();
+            if !vector.is_empty() {
+                return Some(NearVectorInput {
+                    vector,
+                    certainty: extract_float(query, "certainty:"),
+                    distance: extract_float(query, "distance:"),
+                });
+            }
+        }
     }
     None
 }
@@ -695,7 +719,8 @@ fn extract_near_vector(query: &str) -> Option<NearVectorInput> {
 fn extract_float(query: &str, key: &str) -> Option<f32> {
     if let Some(start) = query.find(key) {
         let rest = &query[start + key.len()..];
-        let value: String = rest.trim()
+        let value: String = rest
+            .trim()
             .chars()
             .take_while(|c| c.is_numeric() || *c == '.' || *c == '-')
             .collect();
@@ -713,10 +738,7 @@ fn extract_where(_query: &str) -> Option<WhereFilter> {
 fn extract_limit(query: &str) -> Option<usize> {
     if let Some(start) = query.find("limit:") {
         let rest = &query[start + 6..];
-        let value: String = rest.trim()
-            .chars()
-            .take_while(|c| c.is_numeric())
-            .collect();
+        let value: String = rest.trim().chars().take_while(|c| c.is_numeric()).collect();
         value.parse().ok()
     } else {
         None
@@ -778,14 +800,30 @@ mod tests {
 
         // Insert vectors
         let mut props1 = HashMap::new();
-        props1.insert("title".to_string(), JsonValue::String("Tech News".to_string()));
-        props1.insert("category".to_string(), JsonValue::String("tech".to_string()));
-        executor.insert("Article", "doc1", vec![1.0, 0.0, 0.0, 0.0], props1).unwrap();
+        props1.insert(
+            "title".to_string(),
+            JsonValue::String("Tech News".to_string()),
+        );
+        props1.insert(
+            "category".to_string(),
+            JsonValue::String("tech".to_string()),
+        );
+        executor
+            .insert("Article", "doc1", vec![1.0, 0.0, 0.0, 0.0], props1)
+            .unwrap();
 
         let mut props2 = HashMap::new();
-        props2.insert("title".to_string(), JsonValue::String("Sports News".to_string()));
-        props2.insert("category".to_string(), JsonValue::String("sports".to_string()));
-        executor.insert("Article", "doc2", vec![0.0, 1.0, 0.0, 0.0], props2).unwrap();
+        props2.insert(
+            "title".to_string(),
+            JsonValue::String("Sports News".to_string()),
+        );
+        props2.insert(
+            "category".to_string(),
+            JsonValue::String("sports".to_string()),
+        );
+        executor
+            .insert("Article", "doc2", vec![0.0, 1.0, 0.0, 0.0], props2)
+            .unwrap();
 
         // Execute query
         let query = VectorQuery {
@@ -815,14 +853,12 @@ mod tests {
         let collection = GqlCollection {
             name: "Document".to_string(),
             description: None,
-            fields: vec![
-                GqlField {
-                    name: "content".to_string(),
-                    field_type: GqlType::String,
-                    description: None,
-                    is_vector: false,
-                },
-            ],
+            fields: vec![GqlField {
+                name: "content".to_string(),
+                field_type: GqlType::String,
+                description: None,
+                is_vector: false,
+            }],
             vector_field: None,
             dimension: 4,
         };
diff --git a/src/graphrag.rs b/src/graphrag.rs
index 7773600..1d218aa 100644
--- a/src/graphrag.rs
+++ b/src/graphrag.rs
@@ -31,10 +31,10 @@
 //! let results = graph_rag.query("vector database languages", 5)?;
 //! ```
 
-use std::collections::{HashMap, HashSet, VecDeque};
 use serde::{Deserialize, Serialize};
+use std::collections::{HashMap, HashSet, VecDeque};
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 /// Entity in the knowledge graph
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -187,11 +187,21 @@ pub struct GraphRAGConfig {
     pub use_entity_embeddings: bool,
 }
 
-fn default_vector_weight() -> f32 { 0.7 }
-fn default_graph_weight() -> f32 { 0.3 }
-fn default_max_depth() -> usize { 2 }
-fn default_max_expansion() -> usize { 10 }
-fn default_true() -> bool { true }
+fn default_vector_weight() -> f32 {
+    0.7
+}
+fn default_graph_weight() -> f32 {
+    0.3
+}
+fn default_max_depth() -> usize {
+    2
+}
+fn default_max_expansion() -> usize {
+    10
+}
+fn default_true() -> bool {
+    true
+}
 
 impl Default for GraphRAGConfig {
     fn default() -> Self {
@@ -250,10 +260,16 @@ impl GraphRAG {
     pub fn add_relationship(&mut self, rel: Relationship) -> Result<()> {
         // Verify entities exist
         if !self.entities.contains_key(&rel.from) {
-            return Err(VecStoreError::NotFound(format!("Entity not found: {}", rel.from)));
+            return Err(VecStoreError::NotFound(format!(
+                "Entity not found: {}",
+                rel.from
+            )));
         }
         if !self.entities.contains_key(&rel.to) {
-            return Err(VecStoreError::NotFound(format!("Entity not found: {}", rel.to)));
+            return Err(VecStoreError::NotFound(format!(
+                "Entity not found: {}",
+                rel.to
+            )));
         }
 
         // Add to outgoing edges
@@ -263,10 +279,7 @@ impl GraphRAG {
             .push(rel.clone());
 
         // Add to incoming edges
-        self.incoming
-            .entry(rel.to.clone())
-            .or_default()
-            .push(rel);
+        self.incoming.entry(rel.to.clone()).or_default().push(rel);
 
         Ok(())
     }
@@ -287,7 +300,8 @@ impl GraphRAG {
             });
         }
 
-        let linked_entities: HashSet<String> = entity_ids.iter()
+        let linked_entities: HashSet<String> = entity_ids
+            .iter()
             .filter(|&&id| self.entities.contains_key(id))
             .map(|&s| s.to_string())
             .collect();
@@ -300,23 +314,22 @@ impl GraphRAG {
                 .insert(id.to_string());
         }
 
-        self.documents.insert(id.to_string(), LinkedDocument {
-            id: id.to_string(),
-            content: content.to_string(),
-            embedding,
-            linked_entities,
-            metadata,
-        });
+        self.documents.insert(
+            id.to_string(),
+            LinkedDocument {
+                id: id.to_string(),
+                content: content.to_string(),
+                embedding,
+                linked_entities,
+                metadata,
+            },
+        );
 
         Ok(())
     }
 
     /// Query with graph expansion
-    pub fn query(
-        &self,
-        query_embedding: &[f32],
-        limit: usize,
-    ) -> Result<Vec<GraphRAGResult>> {
+    pub fn query(&self, query_embedding: &[f32], limit: usize) -> Result<Vec<GraphRAGResult>> {
         if query_embedding.len() != self.dimension {
             return Err(VecStoreError::DimensionMismatch {
                 expected: self.dimension,
@@ -335,7 +348,8 @@ impl GraphRAG {
         let expanded_entities = self.expand_entities(&relevant_entities);
 
         // Step 3: Find documents linked to expanded entities
-        let entity_docs: HashSet<&String> = expanded_entities.iter()
+        let entity_docs: HashSet<&String> = expanded_entities
+            .iter()
             .filter_map(|e| self.entity_documents.get(&e.id))
             .flatten()
             .collect();
@@ -348,7 +362,9 @@ impl GraphRAG {
 
             // Calculate graph score based on entity overlap
             let graph_score = if entity_docs.contains(doc_id) {
-                let overlap = doc.linked_entities.iter()
+                let overlap = doc
+                    .linked_entities
+                    .iter()
                     .filter(|e| expanded_entities.iter().any(|exp| exp.id == **e))
                     .count();
                 overlap as f32 / doc.linked_entities.len().max(1) as f32
@@ -356,16 +372,19 @@ impl GraphRAG {
                 0.0
             };
 
-            let combined_score = self.config.vector_weight * vector_score
-                + self.config.graph_weight * graph_score;
+            let combined_score =
+                self.config.vector_weight * vector_score + self.config.graph_weight * graph_score;
 
             // Get linked entities
-            let linked: Vec<Entity> = doc.linked_entities.iter()
+            let linked: Vec<Entity> = doc
+                .linked_entities
+                .iter()
                 .filter_map(|id| self.entities.get(id).cloned())
                 .collect();
 
             // Get related entities (from expansion, not directly linked)
-            let related: Vec<Entity> = expanded_entities.iter()
+            let related: Vec<Entity> = expanded_entities
+                .iter()
                 .filter(|e| !doc.linked_entities.contains(&e.id))
                 .cloned()
                 .collect();
@@ -394,16 +413,19 @@ impl GraphRAG {
 
     /// Find entities similar to query embedding
     fn find_relevant_entities(&self, query: &[f32], limit: usize) -> Vec<Entity> {
-        let mut scored: Vec<(f32, &Entity)> = self.entities.values()
+        let mut scored: Vec<(f32, &Entity)> = self
+            .entities
+            .values()
             .filter_map(|e| {
-                e.embedding.as_ref().map(|emb| {
-                    (Self::cosine_similarity(query, emb), e)
-                })
+                e.embedding
+                    .as_ref()
+                    .map(|emb| (Self::cosine_similarity(query, emb), e))
             })
             .collect();
 
         scored.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap());
-        scored.into_iter()
+        scored
+            .into_iter()
             .take(limit)
             .map(|(_, e)| e.clone())
             .collect()
@@ -436,10 +458,11 @@ impl GraphRAG {
             if let Some(rels) = self.outgoing.get(&entity_id) {
                 for rel in rels {
                     if visited.insert(rel.to.clone())
-                        && let Some(entity) = self.entities.get(&rel.to) {
-                            result.push(entity.clone());
-                            queue.push_back((rel.to.clone(), depth + 1));
-                        }
+                        && let Some(entity) = self.entities.get(&rel.to)
+                    {
+                        result.push(entity.clone());
+                        queue.push_back((rel.to.clone(), depth + 1));
+                    }
                 }
             }
 
@@ -447,10 +470,11 @@ impl GraphRAG {
             if let Some(rels) = self.incoming.get(&entity_id) {
                 for rel in rels {
                     if visited.insert(rel.from.clone())
-                        && let Some(entity) = self.entities.get(&rel.from) {
-                            result.push(entity.clone());
-                            queue.push_back((rel.from.clone(), depth + 1));
-                        }
+                        && let Some(entity) = self.entities.get(&rel.from)
+                    {
+                        result.push(entity.clone());
+                        queue.push_back((rel.from.clone(), depth + 1));
+                    }
                 }
             }
         }
@@ -495,21 +519,24 @@ impl GraphRAG {
 
     /// Get all entities of a type
     pub fn get_entities_by_type(&self, entity_type: &str) -> Vec<&Entity> {
-        self.entities.values()
+        self.entities
+            .values()
             .filter(|e| e.entity_type == entity_type)
             .collect()
     }
 
     /// Get relationships from an entity
     pub fn get_outgoing(&self, entity_id: &str) -> Vec<&Relationship> {
-        self.outgoing.get(entity_id)
+        self.outgoing
+            .get(entity_id)
             .map(|rels| rels.iter().collect())
             .unwrap_or_default()
     }
 
     /// Get relationships to an entity
     pub fn get_incoming(&self, entity_id: &str) -> Vec<&Relationship> {
-        self.incoming.get(entity_id)
+        self.incoming
+            .get(entity_id)
             .map(|rels| rels.iter().collect())
             .unwrap_or_default()
     }
@@ -541,7 +568,9 @@ mod tests {
         let mut graph = GraphRAG::new(64).unwrap();
 
         graph.add_entity(Entity::new("rust", "Language")).unwrap();
-        graph.add_entity(Entity::new("vecstore", "Database")).unwrap();
+        graph
+            .add_entity(Entity::new("vecstore", "Database"))
+            .unwrap();
 
         assert!(graph.get_entity("rust").is_some());
         assert!(graph.get_entity("vecstore").is_some());
@@ -552,11 +581,13 @@ mod tests {
         let mut graph = GraphRAG::new(64).unwrap();
 
         graph.add_entity(Entity::new("rust", "Language")).unwrap();
-        graph.add_entity(Entity::new("vecstore", "Database")).unwrap();
+        graph
+            .add_entity(Entity::new("vecstore", "Database"))
+            .unwrap();
 
-        graph.add_relationship(
-            Relationship::new("vecstore", "rust", "written_in")
-        ).unwrap();
+        graph
+            .add_relationship(Relationship::new("vecstore", "rust", "written_in"))
+            .unwrap();
 
         let outgoing = graph.get_outgoing("vecstore");
         assert_eq!(outgoing.len(), 1);
@@ -568,16 +599,20 @@ mod tests {
         let mut graph = GraphRAG::new(64).unwrap();
 
         graph.add_entity(Entity::new("rust", "Language")).unwrap();
-        graph.add_entity(Entity::new("vecstore", "Database")).unwrap();
+        graph
+            .add_entity(Entity::new("vecstore", "Database"))
+            .unwrap();
 
         let embedding = vec![0.1f32; 64];
-        graph.add_document(
-            "doc1",
-            "VecStore is written in Rust",
-            embedding.clone(),
-            &["rust", "vecstore"],
-            None,
-        ).unwrap();
+        graph
+            .add_document(
+                "doc1",
+                "VecStore is written in Rust",
+                embedding.clone(),
+                &["rust", "vecstore"],
+                None,
+            )
+            .unwrap();
 
         let results = graph.query(&embedding, 5).unwrap();
         assert_eq!(results.len(), 1);
diff --git a/src/health.rs b/src/health.rs
index e240204..406097d 100644
--- a/src/health.rs
+++ b/src/health.rs
@@ -363,13 +363,13 @@ impl HealthChecker {
         // Calculate memory utilization
         // Estimate total system memory (could be made configurable)
         let total_memory_estimate = 16 * 1024 * 1024 * 1024usize; // 16 GB default
-        let memory_utilization = (memory_bytes as f64 / total_memory_estimate as f64 * 100.0)
-            .clamp(0.0, 100.0);
+        let memory_utilization =
+            (memory_bytes as f64 / total_memory_estimate as f64 * 100.0).clamp(0.0, 100.0);
 
         // Calculate disk utilization (assuming 1TB max for simplicity)
         let total_disk_estimate = 1024 * 1024 * 1024 * 1024usize; // 1 TB
-        let disk_utilization = (disk_bytes as f64 / total_disk_estimate as f64 * 100.0)
-            .clamp(0.0, 100.0);
+        let disk_utilization =
+            (disk_bytes as f64 / total_disk_estimate as f64 * 100.0).clamp(0.0, 100.0);
 
         ResourceHealth {
             memory_bytes,
@@ -482,17 +482,18 @@ impl HealthChecker {
 
     fn generate_performance_alerts(&self, perf: &PerformanceHealth, alerts: &mut Vec<Alert>) {
         if let Some(latency) = perf.p95_query_latency_ms
-            && latency >= self.config.latency_warning_ms {
-                alerts.push(Alert {
-                    severity: AlertSeverity::Warning,
-                    category: AlertCategory::Performance,
-                    message: format!("High query latency: {:.2}ms (p95)", latency),
-                    value: Some(latency),
-                    recommendation: Some(
-                        "Check index parameters or consider upgrading hardware".to_string(),
-                    ),
-                });
-            }
+            && latency >= self.config.latency_warning_ms
+        {
+            alerts.push(Alert {
+                severity: AlertSeverity::Warning,
+                category: AlertCategory::Performance,
+                message: format!("High query latency: {:.2}ms (p95)", latency),
+                value: Some(latency),
+                recommendation: Some(
+                    "Check index parameters or consider upgrading hardware".to_string(),
+                ),
+            });
+        }
 
         if perf.performance_score < self.config.min_performance_score {
             alerts.push(Alert {
@@ -633,12 +634,7 @@ pub fn print_health_report(report: &HealthReport) {
                 AlertSeverity::Warning => "⚠️",
                 AlertSeverity::Critical => "❌",
             };
-            println!(
-                "  {} [{:?}] {}",
-                icon,
-                alert.category,
-                alert.message
-            );
+            println!("  {} [{:?}] {}", icon, alert.category, alert.message);
             if let Some(rec) = &alert.recommendation {
                 println!("     → {}", rec);
             }
@@ -696,10 +692,12 @@ mod tests {
 
         // 60% deletion ratio should trigger Unhealthy status
         assert_eq!(report.status, HealthStatus::Unhealthy);
-        assert!(report
-            .alerts
-            .iter()
-            .any(|a| a.severity == AlertSeverity::Critical));
+        assert!(
+            report
+                .alerts
+                .iter()
+                .any(|a| a.severity == AlertSeverity::Critical)
+        );
 
         Ok(())
     }
diff --git a/src/hybrid_rerank.rs b/src/hybrid_rerank.rs
index 6358222..152e5fc 100644
--- a/src/hybrid_rerank.rs
+++ b/src/hybrid_rerank.rs
@@ -464,7 +464,13 @@ impl InvertedIndex {
         idf
     }
 
-    fn search_bm25(&mut self, query_terms: &[String], k1: f32, b: f32, top_k: usize) -> Vec<(String, f32)> {
+    fn search_bm25(
+        &mut self,
+        query_terms: &[String],
+        k1: f32,
+        b: f32,
+        top_k: usize,
+    ) -> Vec<(String, f32)> {
         let mut scores: HashMap<String, f32> = HashMap::new();
 
         for term in query_terms {
@@ -546,7 +552,8 @@ impl DenseIndex {
     }
 
     fn search(&self, query: &[f32], top_k: usize) -> Vec<(String, f32)> {
-        let mut scores: Vec<_> = self.vectors
+        let mut scores: Vec<_> = self
+            .vectors
             .iter()
             .map(|(id, vec)| {
                 let score = cosine_similarity(query, vec);
@@ -594,14 +601,18 @@ impl HybridPipeline {
     pub fn index(&self, doc: HybridDocument) -> Result<()> {
         // Index in dense index
         {
-            let mut dense = self.dense_index.write()
+            let mut dense = self
+                .dense_index
+                .write()
                 .map_err(|_| VecStoreError::LockError("dense_index lock poisoned".into()))?;
             dense.add_document(&doc.id, &doc.dense_vector);
         }
 
         // Index in sparse index if available
         if let Some(sparse) = &doc.sparse_vector {
-            let mut sparse_idx = self.sparse_index.write()
+            let mut sparse_idx = self
+                .sparse_index
+                .write()
                 .map_err(|_| VecStoreError::LockError("sparse_index lock poisoned".into()))?;
             sparse_idx.add_document(&doc.id, sparse);
         }
@@ -609,14 +620,18 @@ impl HybridPipeline {
         // Index in BM25
         {
             let terms = tokenize(&doc.text);
-            let mut bm25 = self.bm25_index.write()
+            let mut bm25 = self
+                .bm25_index
+                .write()
                 .map_err(|_| VecStoreError::LockError("bm25_index lock poisoned".into()))?;
             bm25.add_document(&doc.id, &terms);
         }
 
         // Store document
         {
-            let mut docs = self.documents.write()
+            let mut docs = self
+                .documents
+                .write()
                 .map_err(|_| VecStoreError::LockError("documents lock poisoned".into()))?;
             docs.insert(doc.id.clone(), doc);
         }
@@ -633,46 +648,54 @@ impl HybridPipeline {
 
         // Dense search
         if let Some(ref vector) = query.dense_vector
-            && weights.0 > 0.0 {
-                let dense = self.dense_index.read()
-                    .map_err(|_| VecStoreError::LockError("dense_index lock poisoned".into()))?;
-                let results = dense.search(vector, self.config.max_candidates);
-                let signal_results: Vec<SignalResult> = results
-                    .into_iter()
-                    .enumerate()
-                    .map(|(rank, (id, score))| SignalResult {
-                        id,
-                        score,
-                        rank,
-                        signal: SignalType::Dense,
-                    })
-                    .collect();
-                all_signals.push(signal_results);
-            }
+            && weights.0 > 0.0
+        {
+            let dense = self
+                .dense_index
+                .read()
+                .map_err(|_| VecStoreError::LockError("dense_index lock poisoned".into()))?;
+            let results = dense.search(vector, self.config.max_candidates);
+            let signal_results: Vec<SignalResult> = results
+                .into_iter()
+                .enumerate()
+                .map(|(rank, (id, score))| SignalResult {
+                    id,
+                    score,
+                    rank,
+                    signal: SignalType::Dense,
+                })
+                .collect();
+            all_signals.push(signal_results);
+        }
 
         // Sparse search
         if let Some(ref sparse) = query.sparse_vector
-            && weights.1 > 0.0 {
-                let sparse_idx = self.sparse_index.read()
-                    .map_err(|_| VecStoreError::LockError("sparse_index lock poisoned".into()))?;
-                let results = sparse_idx.search(sparse, self.config.max_candidates);
-                let signal_results: Vec<SignalResult> = results
-                    .into_iter()
-                    .enumerate()
-                    .map(|(rank, (id, score))| SignalResult {
-                        id,
-                        score,
-                        rank,
-                        signal: SignalType::Sparse,
-                    })
-                    .collect();
-                all_signals.push(signal_results);
-            }
+            && weights.1 > 0.0
+        {
+            let sparse_idx = self
+                .sparse_index
+                .read()
+                .map_err(|_| VecStoreError::LockError("sparse_index lock poisoned".into()))?;
+            let results = sparse_idx.search(sparse, self.config.max_candidates);
+            let signal_results: Vec<SignalResult> = results
+                .into_iter()
+                .enumerate()
+                .map(|(rank, (id, score))| SignalResult {
+                    id,
+                    score,
+                    rank,
+                    signal: SignalType::Sparse,
+                })
+                .collect();
+            all_signals.push(signal_results);
+        }
 
         // BM25 search
         if weights.2 > 0.0 && !query.text.is_empty() {
             let query_terms = tokenize(&query.text);
-            let mut bm25 = self.bm25_index.write()
+            let mut bm25 = self
+                .bm25_index
+                .write()
                 .map_err(|_| VecStoreError::LockError("bm25_index lock poisoned".into()))?;
             let results = bm25.search_bm25(&query_terms, 1.2, 0.75, self.config.max_candidates);
             let signal_results: Vec<SignalResult> = results
@@ -693,7 +716,9 @@ impl HybridPipeline {
 
         // Apply reranking if configured
         if let Some(reranker) = &self.reranker {
-            let docs = self.documents.read()
+            let docs = self
+                .documents
+                .read()
                 .map_err(|_| VecStoreError::LockError("documents lock poisoned".into()))?;
             fused = reranker.rerank(&query.text, fused, &docs);
         }
@@ -715,11 +740,19 @@ impl HybridPipeline {
                 o.bm25_weight.unwrap_or(self.config.bm25_weight),
             )
         } else {
-            (self.config.dense_weight, self.config.sparse_weight, self.config.bm25_weight)
+            (
+                self.config.dense_weight,
+                self.config.sparse_weight,
+                self.config.bm25_weight,
+            )
         }
     }
 
-    fn fuse_results(&self, signals: &[Vec<SignalResult>], weights: (f32, f32, f32)) -> Result<Vec<HybridResult>> {
+    fn fuse_results(
+        &self,
+        signals: &[Vec<SignalResult>],
+        weights: (f32, f32, f32),
+    ) -> Result<Vec<HybridResult>> {
         match &self.config.fusion_strategy {
             FusionMethod::RRF { k } => self.fuse_rrf(signals, *k),
             FusionMethod::WeightedSum => self.fuse_weighted_sum(signals, weights),
@@ -733,15 +766,16 @@ impl HybridPipeline {
     }
 
     fn fuse_rrf(&self, signals: &[Vec<SignalResult>], k: f32) -> Result<Vec<HybridResult>> {
-        let mut doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, usize>)> = HashMap::new();
+        let mut doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, usize>)> =
+            HashMap::new();
 
         for signal_results in signals {
             for result in signal_results {
                 let rrf_score = 1.0 / (k + result.rank as f32 + 1.0);
 
-                let entry = doc_scores.entry(result.id.clone()).or_insert_with(|| {
-                    (0.0, HashMap::new(), HashMap::new())
-                });
+                let entry = doc_scores
+                    .entry(result.id.clone())
+                    .or_insert_with(|| (0.0, HashMap::new(), HashMap::new()));
 
                 entry.0 += rrf_score;
                 entry.1.insert(format!("{:?}", result.signal), result.score);
@@ -752,23 +786,30 @@ impl HybridPipeline {
         self.build_results(doc_scores, "RRF")
     }
 
-    fn fuse_weighted_sum(&self, signals: &[Vec<SignalResult>], weights: (f32, f32, f32)) -> Result<Vec<HybridResult>> {
+    fn fuse_weighted_sum(
+        &self,
+        signals: &[Vec<SignalResult>],
+        weights: (f32, f32, f32),
+    ) -> Result<Vec<HybridResult>> {
         let weight_map: HashMap<SignalType, f32> = [
             (SignalType::Dense, weights.0),
             (SignalType::Sparse, weights.1),
             (SignalType::BM25, weights.2),
-        ].into_iter().collect();
+        ]
+        .into_iter()
+        .collect();
 
-        let mut doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, usize>)> = HashMap::new();
+        let mut doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, usize>)> =
+            HashMap::new();
 
         for signal_results in signals {
             for result in signal_results {
                 let weight = weight_map.get(&result.signal).copied().unwrap_or(1.0);
                 let weighted_score = result.score * weight;
 
-                let entry = doc_scores.entry(result.id.clone()).or_insert_with(|| {
-                    (0.0, HashMap::new(), HashMap::new())
-                });
+                let entry = doc_scores
+                    .entry(result.id.clone())
+                    .or_insert_with(|| (0.0, HashMap::new(), HashMap::new()));
 
                 entry.0 += weighted_score;
                 entry.1.insert(format!("{:?}", result.signal), result.score);
@@ -780,13 +821,14 @@ impl HybridPipeline {
     }
 
     fn fuse_max_score(&self, signals: &[Vec<SignalResult>]) -> Result<Vec<HybridResult>> {
-        let mut doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, usize>)> = HashMap::new();
+        let mut doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, usize>)> =
+            HashMap::new();
 
         for signal_results in signals {
             for result in signal_results {
-                let entry = doc_scores.entry(result.id.clone()).or_insert_with(|| {
-                    (0.0, HashMap::new(), HashMap::new())
-                });
+                let entry = doc_scores
+                    .entry(result.id.clone())
+                    .or_insert_with(|| (0.0, HashMap::new(), HashMap::new()));
 
                 if result.score > entry.0 {
                     entry.0 = result.score;
@@ -800,13 +842,16 @@ impl HybridPipeline {
     }
 
     fn fuse_geometric_mean(&self, signals: &[Vec<SignalResult>]) -> Result<Vec<HybridResult>> {
-        let mut doc_data: HashMap<String, (Vec<f32>, HashMap<String, f32>, HashMap<String, usize>)> = HashMap::new();
+        let mut doc_data: HashMap<
+            String,
+            (Vec<f32>, HashMap<String, f32>, HashMap<String, usize>),
+        > = HashMap::new();
 
         for signal_results in signals {
             for result in signal_results {
-                let entry = doc_data.entry(result.id.clone()).or_insert_with(|| {
-                    (Vec::new(), HashMap::new(), HashMap::new())
-                });
+                let entry = doc_data
+                    .entry(result.id.clone())
+                    .or_insert_with(|| (Vec::new(), HashMap::new(), HashMap::new()));
 
                 entry.0.push(result.score.max(0.001)); // Avoid zero
                 entry.1.insert(format!("{:?}", result.signal), result.score);
@@ -814,26 +859,30 @@ impl HybridPipeline {
             }
         }
 
-        let doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, usize>)> = doc_data
-            .into_iter()
-            .map(|(id, (scores, signal_scores, signal_ranks))| {
-                let product: f32 = scores.iter().product();
-                let geom_mean = product.powf(1.0 / scores.len() as f32);
-                (id, (geom_mean, signal_scores, signal_ranks))
-            })
-            .collect();
+        let doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, usize>)> =
+            doc_data
+                .into_iter()
+                .map(|(id, (scores, signal_scores, signal_ranks))| {
+                    let product: f32 = scores.iter().product();
+                    let geom_mean = product.powf(1.0 / scores.len() as f32);
+                    (id, (geom_mean, signal_scores, signal_ranks))
+                })
+                .collect();
 
         self.build_results(doc_scores, "GeometricMean")
     }
 
     fn fuse_harmonic_mean(&self, signals: &[Vec<SignalResult>]) -> Result<Vec<HybridResult>> {
-        let mut doc_data: HashMap<String, (Vec<f32>, HashMap<String, f32>, HashMap<String, usize>)> = HashMap::new();
+        let mut doc_data: HashMap<
+            String,
+            (Vec<f32>, HashMap<String, f32>, HashMap<String, usize>),
+        > = HashMap::new();
 
         for signal_results in signals {
             for result in signal_results {
-                let entry = doc_data.entry(result.id.clone()).or_insert_with(|| {
-                    (Vec::new(), HashMap::new(), HashMap::new())
-                });
+                let entry = doc_data
+                    .entry(result.id.clone())
+                    .or_insert_with(|| (Vec::new(), HashMap::new(), HashMap::new()));
 
                 entry.0.push(result.score.max(0.001));
                 entry.1.insert(format!("{:?}", result.signal), result.score);
@@ -841,26 +890,32 @@ impl HybridPipeline {
             }
         }
 
-        let doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, usize>)> = doc_data
-            .into_iter()
-            .map(|(id, (scores, signal_scores, signal_ranks))| {
-                let sum_reciprocals: f32 = scores.iter().map(|s| 1.0 / s).sum();
-                let harm_mean = scores.len() as f32 / sum_reciprocals;
-                (id, (harm_mean, signal_scores, signal_ranks))
-            })
-            .collect();
+        let doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, usize>)> =
+            doc_data
+                .into_iter()
+                .map(|(id, (scores, signal_scores, signal_ranks))| {
+                    let sum_reciprocals: f32 = scores.iter().map(|s| 1.0 / s).sum();
+                    let harm_mean = scores.len() as f32 / sum_reciprocals;
+                    (id, (harm_mean, signal_scores, signal_ranks))
+                })
+                .collect();
 
         self.build_results(doc_scores, "HarmonicMean")
     }
 
-    fn fuse_voting(&self, signals: &[Vec<SignalResult>], min_votes: usize) -> Result<Vec<HybridResult>> {
-        let mut doc_votes: HashMap<String, (usize, HashMap<String, f32>, HashMap<String, usize>)> = HashMap::new();
+    fn fuse_voting(
+        &self,
+        signals: &[Vec<SignalResult>],
+        min_votes: usize,
+    ) -> Result<Vec<HybridResult>> {
+        let mut doc_votes: HashMap<String, (usize, HashMap<String, f32>, HashMap<String, usize>)> =
+            HashMap::new();
 
         for signal_results in signals {
             for result in signal_results {
-                let entry = doc_votes.entry(result.id.clone()).or_insert_with(|| {
-                    (0, HashMap::new(), HashMap::new())
-                });
+                let entry = doc_votes
+                    .entry(result.id.clone())
+                    .or_insert_with(|| (0, HashMap::new(), HashMap::new()));
 
                 entry.0 += 1;
                 entry.1.insert(format!("{:?}", result.signal), result.score);
@@ -868,18 +923,23 @@ impl HybridPipeline {
             }
         }
 
-        let doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, usize>)> = doc_votes
-            .into_iter()
-            .filter(|(_, (votes, _, _))| *votes >= min_votes)
-            .map(|(id, (votes, signal_scores, signal_ranks))| {
-                (id, (votes as f32, signal_scores, signal_ranks))
-            })
-            .collect();
+        let doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, usize>)> =
+            doc_votes
+                .into_iter()
+                .filter(|(_, (votes, _, _))| *votes >= min_votes)
+                .map(|(id, (votes, signal_scores, signal_ranks))| {
+                    (id, (votes as f32, signal_scores, signal_ranks))
+                })
+                .collect();
 
         self.build_results(doc_scores, "Voting")
     }
 
-    fn fuse_distribution(&self, signals: &[Vec<SignalResult>], weights: (f32, f32, f32)) -> Result<Vec<HybridResult>> {
+    fn fuse_distribution(
+        &self,
+        signals: &[Vec<SignalResult>],
+        weights: (f32, f32, f32),
+    ) -> Result<Vec<HybridResult>> {
         // Normalize scores within each signal, then combine
         let mut normalized_signals = Vec::new();
 
@@ -888,8 +948,14 @@ impl HybridPipeline {
                 continue;
             }
 
-            let max_score = signal_results.iter().map(|r| r.score).fold(f32::NEG_INFINITY, f32::max);
-            let min_score = signal_results.iter().map(|r| r.score).fold(f32::INFINITY, f32::min);
+            let max_score = signal_results
+                .iter()
+                .map(|r| r.score)
+                .fold(f32::NEG_INFINITY, f32::max);
+            let min_score = signal_results
+                .iter()
+                .map(|r| r.score)
+                .fold(f32::INFINITY, f32::min);
             let range = (max_score - min_score).max(0.001);
 
             let normalized: Vec<SignalResult> = signal_results
@@ -913,7 +979,9 @@ impl HybridPipeline {
         doc_scores: HashMap<String, (f32, HashMap<String, f32>, HashMap<String, usize>)>,
         method: &str,
     ) -> Result<Vec<HybridResult>> {
-        let docs = self.documents.read()
+        let docs = self
+            .documents
+            .read()
             .map_err(|_| VecStoreError::LockError("documents lock poisoned".into()))?;
 
         let mut results: Vec<HybridResult> = doc_scores
@@ -952,11 +1020,17 @@ impl HybridPipeline {
 
     /// Get pipeline statistics
     pub fn stats(&self) -> Result<PipelineStats> {
-        let dense = self.dense_index.read()
+        let dense = self
+            .dense_index
+            .read()
             .map_err(|_| VecStoreError::LockError("dense_index lock poisoned".into()))?;
-        let sparse = self.sparse_index.read()
+        let sparse = self
+            .sparse_index
+            .read()
             .map_err(|_| VecStoreError::LockError("sparse_index lock poisoned".into()))?;
-        let bm25 = self.bm25_index.read()
+        let bm25 = self
+            .bm25_index
+            .read()
             .map_err(|_| VecStoreError::LockError("bm25_index lock poisoned".into()))?;
 
         Ok(PipelineStats {
@@ -1018,11 +1092,11 @@ impl Reranker {
                 }
 
                 results.sort_by(|a, b| b.score.total_cmp(&a.score));
-            }
+            },
             _ => {
                 // Other rerankers would call external APIs
                 // For now, return unchanged
-            }
+            },
         }
 
         results
@@ -1070,10 +1144,7 @@ mod tests {
                 id: format!("doc_{}", i),
                 text: format!("This is document {} about machine learning", i),
                 dense_vector: vec![0.1 * i as f32; 128],
-                sparse_vector: Some(SparseQueryVector::new(
-                    vec![1, 2, 3],
-                    vec![0.5, 0.3, 0.2],
-                )),
+                sparse_vector: Some(SparseQueryVector::new(vec![1, 2, 3], vec![0.5, 0.3, 0.2])),
                 metadata: HashMap::new(),
             };
             pipeline.index(doc).unwrap();
@@ -1107,8 +1178,7 @@ mod tests {
             pipeline.index(doc).unwrap();
         }
 
-        let query = HybridSearchQuery::new("Document")
-            .with_dense(vec![2.0; 4]);
+        let query = HybridSearchQuery::new("Document").with_dense(vec![2.0; 4]);
 
         let results = pipeline.search(query).unwrap();
         assert!(!results.is_empty());
@@ -1134,15 +1204,14 @@ mod tests {
             BooleanQuery::Phrase { terms, slop } => {
                 assert_eq!(terms.len(), 2);
                 assert_eq!(slop, 1);
-            }
+            },
             _ => panic!("Expected Phrase query"),
         }
     }
 
     #[test]
     fn test_weight_overrides() {
-        let query = HybridSearchQuery::new("test")
-            .with_weights(0.5, 0.3, 0.2);
+        let query = HybridSearchQuery::new("test").with_weights(0.5, 0.3, 0.2);
 
         let overrides = query.weight_overrides.unwrap();
         assert_eq!(overrides.dense_weight, Some(0.5));
diff --git a/src/import_export.rs b/src/import_export.rs
index 484e0e9..87217c8 100644
--- a/src/import_export.rs
+++ b/src/import_export.rs
@@ -85,7 +85,7 @@ fn value_to_metadata(value: serde_json::Value) -> Metadata {
         serde_json::Value::Object(map) => {
             let fields = map.into_iter().collect();
             Metadata { fields }
-        }
+        },
         _ => Metadata {
             fields: HashMap::new(),
         },
diff --git a/src/incremental_index.rs b/src/incremental_index.rs
index 81f7067..91e3567 100644
--- a/src/incremental_index.rs
+++ b/src/incremental_index.rs
@@ -194,7 +194,12 @@ impl IncrementalIndex {
     }
 
     /// Insert a vector
-    pub fn insert(&self, id: String, vector: Vec<f32>, metadata: Option<serde_json::Value>) -> Result<()> {
+    pub fn insert(
+        &self,
+        id: String,
+        vector: Vec<f32>,
+        metadata: Option<serde_json::Value>,
+    ) -> Result<()> {
         self.validate_vector(&vector)?;
 
         let op = Operation::Insert {
@@ -218,18 +223,29 @@ impl IncrementalIndex {
         };
 
         {
-            let mut vectors = self.delta.vectors.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
+            let mut vectors = self
+                .delta
+                .vectors
+                .write()
+                .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
             let is_new = !vectors.contains_key(&id);
             vectors.insert(id.clone(), entry);
 
             if is_new {
                 self.delta.size.fetch_add(1, Ordering::Relaxed);
-                self.delta.insertion_order.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.push(id.clone());
+                self.delta
+                    .insertion_order
+                    .write()
+                    .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+                    .push(id.clone());
             }
         }
 
         // Remove from tombstones if exists
-        self.tombstones.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.remove(&id);
+        self.tombstones
+            .write()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+            .remove(&id);
 
         self.stats.inserts.fetch_add(1, Ordering::Relaxed);
         self.pending_ops.fetch_add(1, Ordering::Relaxed);
@@ -241,7 +257,12 @@ impl IncrementalIndex {
     }
 
     /// Update a vector
-    pub fn update(&self, id: String, vector: Vec<f32>, metadata: Option<serde_json::Value>) -> Result<()> {
+    pub fn update(
+        &self,
+        id: String,
+        vector: Vec<f32>,
+        metadata: Option<serde_json::Value>,
+    ) -> Result<()> {
         self.validate_vector(&vector)?;
 
         // Check if exists
@@ -269,13 +290,21 @@ impl IncrementalIndex {
         };
 
         {
-            let mut vectors = self.delta.vectors.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
+            let mut vectors = self
+                .delta
+                .vectors
+                .write()
+                .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
             let is_new = !vectors.contains_key(&id);
             vectors.insert(id.clone(), entry);
 
             if is_new {
                 self.delta.size.fetch_add(1, Ordering::Relaxed);
-                self.delta.insertion_order.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.push(id);
+                self.delta
+                    .insertion_order
+                    .write()
+                    .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+                    .push(id);
             }
         }
 
@@ -302,7 +331,11 @@ impl IncrementalIndex {
         // immutable base index instead, which can't be edited in place). Tombstoning a
         // delta-resident vector too would double-count it out of total_vectors(): once via
         // the delta_size decrement here, again via the tombstone subtraction there.
-        let mut vectors = self.delta.vectors.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
+        let mut vectors = self
+            .delta
+            .vectors
+            .write()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
         let removed_from_delta = vectors.remove(&id).is_some();
         if removed_from_delta {
             self.delta.size.fetch_sub(1, Ordering::Relaxed);
@@ -320,7 +353,10 @@ impl IncrementalIndex {
                 deleted_at: current_timestamp(),
                 version: self.wal_sequence.load(Ordering::Relaxed),
             };
-            self.tombstones.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.insert(id.clone(), tombstone);
+            self.tombstones
+                .write()
+                .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+                .insert(id.clone(), tombstone);
         }
 
         self.stats.deletes.fetch_add(1, Ordering::Relaxed);
@@ -333,7 +369,10 @@ impl IncrementalIndex {
     }
 
     /// Batch insert
-    pub fn batch_insert(&self, items: Vec<(String, Vec<f32>, Option<serde_json::Value>)>) -> Result<BatchResult> {
+    pub fn batch_insert(
+        &self,
+        items: Vec<(String, Vec<f32>, Option<serde_json::Value>)>,
+    ) -> Result<BatchResult> {
         let mut succeeded = 0;
         let mut failed = 0;
         let mut errors = Vec::new();
@@ -344,26 +383,32 @@ impl IncrementalIndex {
                 Err(e) => {
                     failed += 1;
                     errors.push((id, e.to_string()));
-                }
+                },
             }
         }
 
-        Ok(BatchResult { succeeded, failed, errors })
+        Ok(BatchResult {
+            succeeded,
+            failed,
+            errors,
+        })
     }
 
     /// Check if vector exists
     pub fn exists(&self, id: &str) -> bool {
         // Check tombstones first
         if let Ok(tombstones) = self.tombstones.read()
-            && tombstones.contains_key(id) {
-                return false;
-            }
+            && tombstones.contains_key(id)
+        {
+            return false;
+        }
 
         // Check delta
         if let Ok(delta) = self.delta.vectors.read()
-            && delta.contains_key(id) {
-                return true;
-            }
+            && delta.contains_key(id)
+        {
+            return true;
+        }
 
         // Check base indexes
         if let Ok(bases) = self.base_indexes.read() {
@@ -415,11 +460,18 @@ impl IncrementalIndex {
         self.validate_vector(query)?;
         self.stats.searches.fetch_add(1, Ordering::Relaxed);
 
-        let tombstones = self.tombstones.read().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
+        let tombstones = self
+            .tombstones
+            .read()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
         let mut results = Vec::new();
 
         // Search delta index
-        let delta_vectors = self.delta.vectors.read().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
+        let delta_vectors = self
+            .delta
+            .vectors
+            .read()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
         for (id, entry) in delta_vectors.iter() {
             if tombstones.contains_key(id) {
                 continue;
@@ -434,7 +486,12 @@ impl IncrementalIndex {
         }
 
         // Search base indexes
-        for base in self.base_indexes.read().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.iter() {
+        for base in self
+            .base_indexes
+            .read()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+            .iter()
+        {
             for (id, entry) in &base.vectors {
                 if tombstones.contains_key(id) || delta_vectors.contains_key(id) {
                     continue; // Skip deleted or overridden
@@ -460,7 +517,9 @@ impl IncrementalIndex {
     pub fn merge(&self) -> Result<MergeResult> {
         // Check if merge already in progress
         if self.merge_in_progress.swap(true, Ordering::SeqCst) {
-            return Err(VecStoreError::InvalidInput("Merge already in progress".into()));
+            return Err(VecStoreError::InvalidInput(
+                "Merge already in progress".into(),
+            ));
         }
 
         let start = Instant::now();
@@ -468,29 +527,49 @@ impl IncrementalIndex {
 
         // Collect all vectors (delta + base - tombstones)
         let mut all_vectors = HashMap::new();
-        let tombstones = self.tombstones.read().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
+        let tombstones = self
+            .tombstones
+            .read()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
 
         // Add base vectors
-        for base in self.base_indexes.read().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.iter() {
+        for base in self
+            .base_indexes
+            .read()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+            .iter()
+        {
             for (id, entry) in &base.vectors {
                 if !tombstones.contains_key(id) {
-                    all_vectors.insert(id.clone(), BaseEntry {
-                        id: id.clone(),
-                        vector: entry.vector.clone(),
-                        metadata: entry.metadata.clone(),
-                    });
+                    all_vectors.insert(
+                        id.clone(),
+                        BaseEntry {
+                            id: id.clone(),
+                            vector: entry.vector.clone(),
+                            metadata: entry.metadata.clone(),
+                        },
+                    );
                 }
             }
         }
 
         // Add/override with delta vectors
-        for (id, entry) in self.delta.vectors.read().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.iter() {
+        for (id, entry) in self
+            .delta
+            .vectors
+            .read()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+            .iter()
+        {
             if !tombstones.contains_key(id) {
-                all_vectors.insert(id.clone(), BaseEntry {
-                    id: id.clone(),
-                    vector: entry.vector.clone(),
-                    metadata: entry.metadata.clone(),
-                });
+                all_vectors.insert(
+                    id.clone(),
+                    BaseEntry {
+                        id: id.clone(),
+                        vector: entry.vector.clone(),
+                        metadata: entry.metadata.clone(),
+                    },
+                );
             }
         }
         drop(tombstones);
@@ -506,32 +585,59 @@ impl IncrementalIndex {
 
         // Replace indexes
         {
-            let mut bases = self.base_indexes.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
+            let mut bases = self
+                .base_indexes
+                .write()
+                .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
             let _old_count = bases.len();
             bases.clear();
             bases.push(new_base);
 
             // Clear delta
-            self.delta.vectors.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.clear();
-            self.delta.insertion_order.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.clear();
+            self.delta
+                .vectors
+                .write()
+                .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+                .clear();
+            self.delta
+                .insertion_order
+                .write()
+                .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+                .clear();
             self.delta.size.store(0, Ordering::Relaxed);
 
             // Clear tombstones
-            let cleaned = self.tombstones.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.len();
-            self.tombstones.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.clear();
-
-            self.stats.tombstones_cleaned.fetch_add(cleaned as u64, Ordering::Relaxed);
+            let cleaned = self
+                .tombstones
+                .write()
+                .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+                .len();
+            self.tombstones
+                .write()
+                .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+                .clear();
+
+            self.stats
+                .tombstones_cleaned
+                .fetch_add(cleaned as u64, Ordering::Relaxed);
         }
 
         // Update state
-        *self.last_merge.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))? = Instant::now();
+        *self
+            .last_merge
+            .write()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))? = Instant::now();
         self.pending_ops.store(0, Ordering::Relaxed);
         self.merge_in_progress.store(false, Ordering::SeqCst);
         self.stats.merges.fetch_add(1, Ordering::Relaxed);
 
         Ok(MergeResult {
             vectors_merged: delta_size,
-            new_index_size: self.base_indexes.read().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?[0].vector_count,
+            new_index_size: self
+                .base_indexes
+                .read()
+                .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?[0]
+                .vector_count,
             duration: start.elapsed(),
             tombstones_removed: 0,
         })
@@ -543,7 +649,11 @@ impl IncrementalIndex {
             return Ok(0);
         }
 
-        let tombstone_count = self.tombstones.read().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.len();
+        let tombstone_count = self
+            .tombstones
+            .read()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+            .len();
         let total_vectors = self.total_vectors();
 
         if total_vectors == 0 {
@@ -581,11 +691,22 @@ impl IncrementalIndex {
             checksum: 0, // In production: compute actual checksum
         };
 
-        self.wal_buffer.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.push_back(entry);
-        self.stats.wal_entries_written.fetch_add(1, Ordering::Relaxed);
+        self.wal_buffer
+            .write()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+            .push_back(entry);
+        self.stats
+            .wal_entries_written
+            .fetch_add(1, Ordering::Relaxed);
 
         // Flush if buffer is large
-        if self.wal_buffer.read().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.len() > 1000 {
+        if self
+            .wal_buffer
+            .read()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+            .len()
+            > 1000
+        {
             self.flush_wal()?;
         }
 
@@ -594,7 +715,10 @@ impl IncrementalIndex {
 
     fn flush_wal(&self) -> Result<()> {
         // In production: write to disk
-        let mut buffer = self.wal_buffer.write().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
+        let mut buffer = self
+            .wal_buffer
+            .write()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?;
         buffer.clear();
         Ok(())
     }
@@ -603,8 +727,7 @@ impl IncrementalIndex {
         let delta_size = self.delta.size.load(Ordering::Relaxed);
         let pending = self.pending_ops.load(Ordering::Relaxed);
 
-        if delta_size >= self.config.delta_size_threshold
-            || pending >= self.config.merge_threshold
+        if delta_size >= self.config.delta_size_threshold || pending >= self.config.merge_threshold
         {
             // In production: spawn background task
             // For now, merge synchronously
@@ -615,7 +738,11 @@ impl IncrementalIndex {
     }
 
     fn maybe_trigger_cleanup(&self) -> Result<()> {
-        let tombstone_count = self.tombstones.read().map_err(|_| VecStoreError::LockError("lock poisoned".into()))?.len();
+        let tombstone_count = self
+            .tombstones
+            .read()
+            .map_err(|_| VecStoreError::LockError("lock poisoned".into()))?
+            .len();
         let total = self.total_vectors();
 
         if total > 0 {
@@ -631,7 +758,9 @@ impl IncrementalIndex {
     /// Get total vector count
     pub fn total_vectors(&self) -> usize {
         let delta_size = self.delta.size.load(Ordering::Relaxed);
-        let base_size: usize = self.base_indexes.read()
+        let base_size: usize = self
+            .base_indexes
+            .read()
             .map(|b| b.iter().map(|b| b.vector_count).sum())
             .unwrap_or(0);
         let tombstone_count = self.tombstones.read().map(|t| t.len()).unwrap_or(0);
@@ -744,27 +873,38 @@ impl WalRecovery {
 
         for entry in entries {
             match entry.operation {
-                Operation::Insert { id, vector, metadata } => {
+                Operation::Insert {
+                    id,
+                    vector,
+                    metadata,
+                } => {
                     if index.insert(id, vector, metadata).is_ok() {
                         replayed += 1;
                     } else {
                         errors += 1;
                     }
-                }
-                Operation::Update { id, vector, metadata } => {
+                },
+                Operation::Update {
+                    id,
+                    vector,
+                    metadata,
+                } => {
                     // For updates, treat as insert if not exists
-                    if index.update(id.clone(), vector.clone(), metadata.clone()).is_err() {
+                    if index
+                        .update(id.clone(), vector.clone(), metadata.clone())
+                        .is_err()
+                    {
                         let _ = index.insert(id, vector, metadata);
                     }
                     replayed += 1;
-                }
+                },
                 Operation::Delete { id } => {
                     if index.delete(id).is_ok() {
                         replayed += 1;
                     } else {
                         errors += 1;
                     }
-                }
+                },
                 Operation::BatchInsert { items } => {
                     for (id, vector, metadata) in items {
                         if index.insert(id, vector, metadata).is_ok() {
@@ -773,7 +913,7 @@ impl WalRecovery {
                             errors += 1;
                         }
                     }
-                }
+                },
             }
         }
 
@@ -801,9 +941,15 @@ mod tests {
     fn test_insert_and_search() {
         let index = IncrementalIndex::new(3, IncrementalConfig::default());
 
-        index.insert("v1".to_string(), vec![1.0, 0.0, 0.0], None).unwrap();
-        index.insert("v2".to_string(), vec![0.0, 1.0, 0.0], None).unwrap();
-        index.insert("v3".to_string(), vec![0.0, 0.0, 1.0], None).unwrap();
+        index
+            .insert("v1".to_string(), vec![1.0, 0.0, 0.0], None)
+            .unwrap();
+        index
+            .insert("v2".to_string(), vec![0.0, 1.0, 0.0], None)
+            .unwrap();
+        index
+            .insert("v3".to_string(), vec![0.0, 0.0, 1.0], None)
+            .unwrap();
 
         let results = index.search(&[1.0, 0.1, 0.0], 2).unwrap();
 
@@ -815,12 +961,16 @@ mod tests {
     fn test_update() {
         let index = IncrementalIndex::new(3, IncrementalConfig::default());
 
-        index.insert("v1".to_string(), vec![1.0, 0.0, 0.0], None).unwrap();
+        index
+            .insert("v1".to_string(), vec![1.0, 0.0, 0.0], None)
+            .unwrap();
 
         let entry1 = index.get("v1").unwrap();
         assert_eq!(entry1.vector, vec![1.0, 0.0, 0.0]);
 
-        index.update("v1".to_string(), vec![0.0, 1.0, 0.0], None).unwrap();
+        index
+            .update("v1".to_string(), vec![0.0, 1.0, 0.0], None)
+            .unwrap();
 
         let entry2 = index.get("v1").unwrap();
         assert_eq!(entry2.vector, vec![0.0, 1.0, 0.0]);
@@ -830,7 +980,9 @@ mod tests {
     fn test_delete() {
         let index = IncrementalIndex::new(3, IncrementalConfig::default());
 
-        index.insert("v1".to_string(), vec![1.0, 0.0, 0.0], None).unwrap();
+        index
+            .insert("v1".to_string(), vec![1.0, 0.0, 0.0], None)
+            .unwrap();
         assert!(index.exists("v1"));
 
         index.delete("v1".to_string()).unwrap();
@@ -848,11 +1000,9 @@ mod tests {
 
         // Insert vectors
         for i in 0..100 {
-            index.insert(
-                format!("v{}", i),
-                vec![i as f32, 0.0, 0.0],
-                None,
-            ).unwrap();
+            index
+                .insert(format!("v{}", i), vec![i as f32, 0.0, 0.0], None)
+                .unwrap();
         }
 
         let stats_before = index.get_stats();
@@ -883,7 +1033,9 @@ mod tests {
         // deletes -- a delta-resident vector is removed directly since delta is mutable (see
         // delete()'s comment), so deleting straight out of delta never produces a tombstone.
         for i in 0..10 {
-            index.insert(format!("v{}", i), vec![i as f32, 0.0, 0.0], None).unwrap();
+            index
+                .insert(format!("v{}", i), vec![i as f32, 0.0, 0.0], None)
+                .unwrap();
         }
         index.merge().unwrap();
 
diff --git a/src/inference.rs b/src/inference.rs
index 010bc51..1b36a63 100644
--- a/src/inference.rs
+++ b/src/inference.rs
@@ -30,11 +30,11 @@
 //! let results = engine.query_text("greeting", 10)?;
 //! ```
 
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::{Arc, RwLock};
-use serde::{Deserialize, Serialize};
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 /// Embedding provider configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -47,15 +47,9 @@ pub enum EmbeddingProvider {
         dimensions: Option<usize>,
     },
     /// Cohere embeddings (embed-english-v3.0, embed-multilingual-v3.0)
-    Cohere {
-        model: String,
-        api_key: String,
-    },
+    Cohere { model: String, api_key: String },
     /// Voyage AI embeddings (voyage-3, voyage-3-lite, voyage-code-3)
-    VoyageAI {
-        model: String,
-        api_key: String,
-    },
+    VoyageAI { model: String, api_key: String },
     /// Google Vertex AI embeddings
     VertexAI {
         model: String,
@@ -68,15 +62,9 @@ pub enum EmbeddingProvider {
         tokenizer_path: String,
     },
     /// Ollama local models
-    Ollama {
-        model: String,
-        base_url: String,
-    },
+    Ollama { model: String, base_url: String },
     /// HuggingFace Inference API
-    HuggingFace {
-        model: String,
-        api_key: String,
-    },
+    HuggingFace { model: String, api_key: String },
     /// Custom HTTP endpoint
     Custom {
         endpoint: String,
@@ -89,47 +77,39 @@ impl EmbeddingProvider {
     /// Get the default dimension for this provider/model
     pub fn default_dimension(&self) -> usize {
         match self {
-            EmbeddingProvider::OpenAI { model, dimensions, .. } => {
-                dimensions.unwrap_or_else(|| match model.as_str() {
-                    "text-embedding-3-small" => 1536,
-                    "text-embedding-3-large" => 3072,
-                    "text-embedding-ada-002" => 1536,
-                    _ => 1536,
-                })
-            }
-            EmbeddingProvider::Cohere { model, .. } => {
-                match model.as_str() {
-                    "embed-english-v3.0" => 1024,
-                    "embed-multilingual-v3.0" => 1024,
-                    "embed-english-light-v3.0" => 384,
-                    _ => 1024,
-                }
-            }
-            EmbeddingProvider::VoyageAI { model, .. } => {
-                match model.as_str() {
-                    "voyage-3" => 1024,
-                    "voyage-3-lite" => 512,
-                    "voyage-code-3" => 1024,
-                    _ => 1024,
-                }
-            }
-            EmbeddingProvider::VertexAI { model, .. } => {
-                match model.as_str() {
-                    "textembedding-gecko@003" => 768,
-                    "text-embedding-004" => 768,
-                    "text-multilingual-embedding-002" => 768,
-                    _ => 768,
-                }
-            }
+            EmbeddingProvider::OpenAI {
+                model, dimensions, ..
+            } => dimensions.unwrap_or_else(|| match model.as_str() {
+                "text-embedding-3-small" => 1536,
+                "text-embedding-3-large" => 3072,
+                "text-embedding-ada-002" => 1536,
+                _ => 1536,
+            }),
+            EmbeddingProvider::Cohere { model, .. } => match model.as_str() {
+                "embed-english-v3.0" => 1024,
+                "embed-multilingual-v3.0" => 1024,
+                "embed-english-light-v3.0" => 384,
+                _ => 1024,
+            },
+            EmbeddingProvider::VoyageAI { model, .. } => match model.as_str() {
+                "voyage-3" => 1024,
+                "voyage-3-lite" => 512,
+                "voyage-code-3" => 1024,
+                _ => 1024,
+            },
+            EmbeddingProvider::VertexAI { model, .. } => match model.as_str() {
+                "textembedding-gecko@003" => 768,
+                "text-embedding-004" => 768,
+                "text-multilingual-embedding-002" => 768,
+                _ => 768,
+            },
             EmbeddingProvider::LocalONNX { .. } => 384, // Default for MiniLM
-            EmbeddingProvider::Ollama { model, .. } => {
-                match model.as_str() {
-                    "nomic-embed-text" => 768,
-                    "mxbai-embed-large" => 1024,
-                    "all-minilm" => 384,
-                    _ => 768,
-                }
-            }
+            EmbeddingProvider::Ollama { model, .. } => match model.as_str() {
+                "nomic-embed-text" => 768,
+                "mxbai-embed-large" => 1024,
+                "all-minilm" => 384,
+                _ => 768,
+            },
             EmbeddingProvider::HuggingFace { model, .. } => {
                 if model.contains("minilm") || model.contains("MiniLM") {
                     384
@@ -138,7 +118,7 @@ impl EmbeddingProvider {
                 } else {
                     768
                 }
-            }
+            },
             EmbeddingProvider::Custom { .. } => 768, // Default
         }
     }
@@ -180,10 +160,18 @@ pub struct InferenceConfig {
     pub timeout_ms: u64,
 }
 
-fn default_batch_size() -> usize { 100 }
-fn default_true() -> bool { true }
-fn default_cache_size() -> usize { 10000 }
-fn default_timeout() -> u64 { 30000 }
+fn default_batch_size() -> usize {
+    100
+}
+fn default_true() -> bool {
+    true
+}
+fn default_cache_size() -> usize {
+    10000
+}
+fn default_timeout() -> u64 {
+    30000
+}
 
 impl InferenceConfig {
     /// Create a new inference configuration
@@ -280,14 +268,15 @@ impl EmbeddingCache {
     /// Get an embedding from cache
     pub fn get(&mut self, key: &str, model: &str) -> Option<Vec<f32>> {
         if let Some(entry) = self.entries.get(key)
-            && entry.model == model {
-                // Move to end (most recently used)
-                if let Some(pos) = self.order.iter().position(|k| k == key) {
-                    self.order.remove(pos);
-                    self.order.push(key.to_string());
-                }
-                return Some(entry.embedding.clone());
+            && entry.model == model
+        {
+            // Move to end (most recently used)
+            if let Some(pos) = self.order.iter().position(|k| k == key) {
+                self.order.remove(pos);
+                self.order.push(key.to_string());
             }
+            return Some(entry.embedding.clone());
+        }
         None
     }
 
@@ -301,11 +290,14 @@ impl EmbeddingCache {
             }
         }
 
-        self.entries.insert(key.clone(), CacheEntry {
-            embedding,
-            model,
-            created_at: std::time::Instant::now(),
-        });
+        self.entries.insert(
+            key.clone(),
+            CacheEntry {
+                embedding,
+                model,
+                created_at: std::time::Instant::now(),
+            },
+        );
         self.order.push(key);
     }
 
@@ -382,16 +374,19 @@ impl InferenceEngine {
 
     /// Get current statistics
     pub fn stats(&self) -> InferenceStats {
-        let Ok(guard) = self.stats.read() else { return InferenceStats::default(); };
+        let Ok(guard) = self.stats.read() else {
+            return InferenceStats::default();
+        };
         guard.clone()
     }
 
     /// Embed a single text
     pub fn embed(&self, text: &str) -> Result<Vec<f32>> {
         let embeddings = self.embed_batch(&[text.to_string()])?;
-        embeddings.into_iter().next().ok_or_else(|| {
-            VecStoreError::InvalidInput("No embedding returned".to_string())
-        })
+        embeddings
+            .into_iter()
+            .next()
+            .ok_or_else(|| VecStoreError::InvalidInput("No embedding returned".to_string()))
     }
 
     /// Embed a batch of texts
@@ -413,20 +408,31 @@ impl InferenceEngine {
 
         // Check cache first
         if self.config.cache_enabled {
-            let mut cache = self.cache.write()
-                .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on embedding cache".into()))?;
+            let mut cache = self.cache.write().map_err(|_| {
+                VecStoreError::LockError("Failed to acquire write lock on embedding cache".into())
+            })?;
             for (i, text) in texts.iter().enumerate() {
                 let cache_key = Self::cache_key(text);
                 if let Some(embedding) = cache.get(&cache_key, &model_name) {
                     results[i] = Some(embedding);
-                    self.stats.write()
-                        .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on inference stats".into()))?
+                    self.stats
+                        .write()
+                        .map_err(|_| {
+                            VecStoreError::LockError(
+                                "Failed to acquire write lock on inference stats".into(),
+                            )
+                        })?
                         .cache_hits += 1;
                 } else {
                     uncached_indices.push(i);
                     uncached_texts.push(text.clone());
-                    self.stats.write()
-                        .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on inference stats".into()))?
+                    self.stats
+                        .write()
+                        .map_err(|_| {
+                            VecStoreError::LockError(
+                                "Failed to acquire write lock on inference stats".into(),
+                            )
+                        })?
                         .cache_misses += 1;
                 }
             }
@@ -441,8 +447,11 @@ impl InferenceEngine {
 
             // Update cache and results
             if self.config.cache_enabled {
-                let mut cache = self.cache.write()
-                    .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on embedding cache".into()))?;
+                let mut cache = self.cache.write().map_err(|_| {
+                    VecStoreError::LockError(
+                        "Failed to acquire write lock on embedding cache".into(),
+                    )
+                })?;
                 for (i, embedding) in new_embeddings.into_iter().enumerate() {
                     let orig_idx = uncached_indices[i];
                     let cache_key = Self::cache_key(&uncached_texts[i]);
@@ -458,13 +467,15 @@ impl InferenceEngine {
 
         // Update stats
         {
-            let mut stats = self.stats.write()
-                .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on inference stats".into()))?;
+            let mut stats = self.stats.write().map_err(|_| {
+                VecStoreError::LockError("Failed to acquire write lock on inference stats".into())
+            })?;
             stats.total_requests += 1;
             stats.total_embeddings += texts.len() as u64;
         }
 
-        results.into_iter()
+        results
+            .into_iter()
             .map(|r| r.ok_or_else(|| VecStoreError::InvalidInput("Missing embedding".to_string())))
             .collect()
     }
@@ -482,30 +493,30 @@ impl InferenceEngine {
     /// Generate embeddings using the configured provider
     fn generate_embeddings(&self, texts: &[String]) -> Result<Vec<Vec<f32>>> {
         match &self.config.provider {
-            EmbeddingProvider::OpenAI { model, api_key, dimensions } => {
-                self.embed_openai(texts, model, api_key, *dimensions)
-            }
+            EmbeddingProvider::OpenAI {
+                model,
+                api_key,
+                dimensions,
+            } => self.embed_openai(texts, model, api_key, *dimensions),
             EmbeddingProvider::Cohere { model, api_key } => {
                 self.embed_cohere(texts, model, api_key)
-            }
+            },
             EmbeddingProvider::VoyageAI { model, api_key } => {
                 self.embed_voyageai(texts, model, api_key)
-            }
+            },
             EmbeddingProvider::Ollama { model, base_url } => {
                 self.embed_ollama(texts, model, base_url)
-            }
-            EmbeddingProvider::LocalONNX { .. } => {
-                self.embed_local_placeholder(texts)
-            }
-            EmbeddingProvider::VertexAI { .. } => {
-                self.embed_local_placeholder(texts)
-            }
+            },
+            EmbeddingProvider::LocalONNX { .. } => self.embed_local_placeholder(texts),
+            EmbeddingProvider::VertexAI { .. } => self.embed_local_placeholder(texts),
             EmbeddingProvider::HuggingFace { model, api_key } => {
                 self.embed_huggingface(texts, model, api_key)
-            }
-            EmbeddingProvider::Custom { endpoint, api_key, headers } => {
-                self.embed_custom(texts, endpoint, api_key.as_deref(), headers)
-            }
+            },
+            EmbeddingProvider::Custom {
+                endpoint,
+                api_key,
+                headers,
+            } => self.embed_custom(texts, endpoint, api_key.as_deref(), headers),
         }
     }
 
@@ -535,7 +546,9 @@ impl InferenceEngine {
             .header("Content-Type", "application/json")
             .json(&body)
             .send()
-            .map_err(|e| VecStoreError::Internal(format!("OpenAI embeddings request failed: {}", e)))?;
+            .map_err(|e| {
+                VecStoreError::Internal(format!("OpenAI embeddings request failed: {}", e))
+            })?;
 
         if !response.status().is_success() {
             let status = response.status();
@@ -546,18 +559,20 @@ impl InferenceEngine {
             )));
         }
 
-        let json: serde_json::Value = response
-            .json()
-            .map_err(|e| VecStoreError::Internal(format!("Failed to parse OpenAI response: {}", e)))?;
+        let json: serde_json::Value = response.json().map_err(|e| {
+            VecStoreError::Internal(format!("Failed to parse OpenAI response: {}", e))
+        })?;
 
         let embeddings: Vec<Vec<f32>> = json["data"]
             .as_array()
             .ok_or_else(|| VecStoreError::Internal("No data in OpenAI response".to_string()))?
             .iter()
             .filter_map(|item| {
-                item["embedding"]
-                    .as_array()
-                    .map(|arr| arr.iter().filter_map(|v| v.as_f64().map(|f| f as f32)).collect())
+                item["embedding"].as_array().map(|arr| {
+                    arr.iter()
+                        .filter_map(|v| v.as_f64().map(|f| f as f32))
+                        .collect()
+                })
             })
             .collect();
 
@@ -574,9 +589,10 @@ impl InferenceEngine {
         dimensions: Option<usize>,
     ) -> Result<Vec<Vec<f32>>> {
         let dim = dimensions.unwrap_or(self.dimension);
-        Ok(texts.iter().map(|text| {
-            Self::deterministic_embedding(text, dim)
-        }).collect())
+        Ok(texts
+            .iter()
+            .map(|text| Self::deterministic_embedding(text, dim))
+            .collect())
     }
 
     /// Cohere embedding implementation
@@ -586,9 +602,10 @@ impl InferenceEngine {
         _model: &str,
         _api_key: &str,
     ) -> Result<Vec<Vec<f32>>> {
-        Ok(texts.iter().map(|text| {
-            Self::deterministic_embedding(text, self.dimension)
-        }).collect())
+        Ok(texts
+            .iter()
+            .map(|text| Self::deterministic_embedding(text, self.dimension))
+            .collect())
     }
 
     /// Voyage AI embedding implementation
@@ -598,19 +615,15 @@ impl InferenceEngine {
         _model: &str,
         _api_key: &str,
     ) -> Result<Vec<Vec<f32>>> {
-        Ok(texts.iter().map(|text| {
-            Self::deterministic_embedding(text, self.dimension)
-        }).collect())
+        Ok(texts
+            .iter()
+            .map(|text| Self::deterministic_embedding(text, self.dimension))
+            .collect())
     }
 
     /// Ollama embedding implementation
     #[cfg(feature = "ollama")]
-    fn embed_ollama(
-        &self,
-        texts: &[String],
-        model: &str,
-        base_url: &str,
-    ) -> Result<Vec<Vec<f32>>> {
+    fn embed_ollama(&self, texts: &[String], model: &str, base_url: &str) -> Result<Vec<Vec<f32>>> {
         let client = reqwest::blocking::Client::new();
         let url = format!("{}/api/embeddings", base_url.trim_end_matches('/'));
 
@@ -628,7 +641,9 @@ impl InferenceEngine {
                 .header("Content-Type", "application/json")
                 .json(&body)
                 .send()
-                .map_err(|e| VecStoreError::Internal(format!("Ollama embeddings request failed: {}", e)))?;
+                .map_err(|e| {
+                    VecStoreError::Internal(format!("Ollama embeddings request failed: {}", e))
+                })?;
 
             if !response.status().is_success() {
                 let status = response.status();
@@ -639,13 +654,15 @@ impl InferenceEngine {
                 )));
             }
 
-            let json: serde_json::Value = response
-                .json()
-                .map_err(|e| VecStoreError::Internal(format!("Failed to parse Ollama response: {}", e)))?;
+            let json: serde_json::Value = response.json().map_err(|e| {
+                VecStoreError::Internal(format!("Failed to parse Ollama response: {}", e))
+            })?;
 
             let embedding: Vec<f32> = json["embedding"]
                 .as_array()
-                .ok_or_else(|| VecStoreError::Internal("No embedding in Ollama response".to_string()))?
+                .ok_or_else(|| {
+                    VecStoreError::Internal("No embedding in Ollama response".to_string())
+                })?
                 .iter()
                 .filter_map(|v| v.as_f64().map(|f| f as f32))
                 .collect();
@@ -664,9 +681,10 @@ impl InferenceEngine {
         _model: &str,
         _base_url: &str,
     ) -> Result<Vec<Vec<f32>>> {
-        Ok(texts.iter().map(|text| {
-            Self::deterministic_embedding(text, self.dimension)
-        }).collect())
+        Ok(texts
+            .iter()
+            .map(|text| Self::deterministic_embedding(text, self.dimension))
+            .collect())
     }
 
     /// HuggingFace embedding implementation
@@ -676,9 +694,10 @@ impl InferenceEngine {
         _model: &str,
         _api_key: &str,
     ) -> Result<Vec<Vec<f32>>> {
-        Ok(texts.iter().map(|text| {
-            Self::deterministic_embedding(text, self.dimension)
-        }).collect())
+        Ok(texts
+            .iter()
+            .map(|text| Self::deterministic_embedding(text, self.dimension))
+            .collect())
     }
 
     /// Custom endpoint embedding implementation
@@ -689,9 +708,10 @@ impl InferenceEngine {
         _api_key: Option<&str>,
         _headers: &HashMap<String, String>,
     ) -> Result<Vec<Vec<f32>>> {
-        Ok(texts.iter().map(|text| {
-            Self::deterministic_embedding(text, self.dimension)
-        }).collect())
+        Ok(texts
+            .iter()
+            .map(|text| Self::deterministic_embedding(text, self.dimension))
+            .collect())
     }
 
     /// Fallback embedding when ONNX/VertexAI features are not enabled.
@@ -703,10 +723,13 @@ impl InferenceEngine {
     /// These embeddings preserve some semantic similarity (same words produce similar hashes)
     /// but are not suitable for production semantic search.
     fn embed_local_placeholder(&self, texts: &[String]) -> Result<Vec<Vec<f32>>> {
-        tracing::debug!("Using placeholder embeddings - enable 'embeddings' feature for real ONNX inference");
-        Ok(texts.iter().map(|text| {
-            Self::deterministic_embedding(text, self.dimension)
-        }).collect())
+        tracing::debug!(
+            "Using placeholder embeddings - enable 'embeddings' feature for real ONNX inference"
+        );
+        Ok(texts
+            .iter()
+            .map(|text| Self::deterministic_embedding(text, self.dimension))
+            .collect())
     }
 
     /// Create a deterministic embedding from text (for testing/fallback)
@@ -741,13 +764,20 @@ impl InferenceEngine {
 
     /// Clear the embedding cache
     pub fn clear_cache(&self) {
-        let Ok(mut cache) = self.cache.write() else { return; };
+        let Ok(mut cache) = self.cache.write() else {
+            return;
+        };
         cache.clear();
     }
 
     /// Get cache statistics
     pub fn cache_stats(&self) -> CacheStats {
-        let Ok(cache) = self.cache.read() else { return CacheStats { size: 0, max_size: 0 }; };
+        let Ok(cache) = self.cache.read() else {
+            return CacheStats {
+                size: 0,
+                max_size: 0,
+            };
+        };
         cache.stats()
     }
 }
diff --git a/src/ivf_pq.rs b/src/ivf_pq.rs
index 1b2dc3c..72d8727 100644
--- a/src/ivf_pq.rs
+++ b/src/ivf_pq.rs
@@ -51,7 +51,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 
diff --git a/src/k8s_operator.rs b/src/k8s_operator.rs
index b49e82d..a7a7064 100644
--- a/src/k8s_operator.rs
+++ b/src/k8s_operator.rs
@@ -303,7 +303,12 @@ impl VecStoreOperator {
     }
 
     /// Handle cluster creation
-    pub fn handle_create(&self, name: &str, namespace: &str, spec: VecStoreClusterSpec) -> Result<()> {
+    pub fn handle_create(
+        &self,
+        name: &str,
+        namespace: &str,
+        spec: VecStoreClusterSpec,
+    ) -> Result<()> {
         let cluster = ManagedCluster {
             name: name.to_string(),
             namespace: namespace.to_string(),
@@ -325,8 +330,11 @@ impl VecStoreOperator {
         };
 
         let key = format!("{}/{}", namespace, name);
-        self.clusters.write()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on clusters".into()))?
+        self.clusters
+            .write()
+            .map_err(|_| {
+                VecStoreError::LockError("Failed to acquire write lock on clusters".into())
+            })?
             .insert(key.clone(), cluster);
 
         // Queue reconciliation
@@ -336,10 +344,16 @@ impl VecStoreOperator {
     }
 
     /// Handle cluster update
-    pub fn handle_update(&self, name: &str, namespace: &str, spec: VecStoreClusterSpec) -> Result<()> {
+    pub fn handle_update(
+        &self,
+        name: &str,
+        namespace: &str,
+        spec: VecStoreClusterSpec,
+    ) -> Result<()> {
         let key = format!("{}/{}", namespace, name);
-        let mut clusters = self.clusters.write()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on clusters".into()))?;
+        let mut clusters = self.clusters.write().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire write lock on clusters".into())
+        })?;
 
         if let Some(cluster) = clusters.get_mut(&key) {
             cluster.spec = spec;
@@ -347,7 +361,10 @@ impl VecStoreOperator {
             self.queue_reconcile(name, namespace, ReconcileTrigger::Update);
             Ok(())
         } else {
-            Err(VecStoreError::NotFound(format!("Cluster {} not found", key)))
+            Err(VecStoreError::NotFound(format!(
+                "Cluster {} not found",
+                key
+            )))
         }
     }
 
@@ -357,8 +374,12 @@ impl VecStoreOperator {
         self.queue_reconcile(name, namespace, ReconcileTrigger::Delete);
 
         // Mark for deletion (actual removal after cleanup)
-        if let Some(cluster) = self.clusters.write()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on clusters".into()))?
+        if let Some(cluster) = self
+            .clusters
+            .write()
+            .map_err(|_| {
+                VecStoreError::LockError("Failed to acquire write lock on clusters".into())
+            })?
             .get_mut(&key)
         {
             cluster.status.phase = ClusterPhase::Terminating;
@@ -375,7 +396,9 @@ impl VecStoreOperator {
             trigger,
             queued_at: Instant::now(),
         };
-        let Ok(mut queue) = self.reconcile_queue.write() else { return; };
+        let Ok(mut queue) = self.reconcile_queue.write() else {
+            return;
+        };
         queue.push(request);
     }
 
@@ -389,22 +412,25 @@ impl VecStoreOperator {
         // Update metrics
         use std::sync::atomic::Ordering;
         self.metrics.reconcile_total.fetch_add(1, Ordering::Relaxed);
-        self.metrics.reconcile_duration_sum.fetch_add(
-            start.elapsed().as_millis() as u64,
-            Ordering::Relaxed,
-        );
+        self.metrics
+            .reconcile_duration_sum
+            .fetch_add(start.elapsed().as_millis() as u64, Ordering::Relaxed);
 
         if result.is_err() {
-            self.metrics.reconcile_errors.fetch_add(1, Ordering::Relaxed);
+            self.metrics
+                .reconcile_errors
+                .fetch_add(1, Ordering::Relaxed);
         }
 
         result
     }
 
     fn do_reconcile(&self, key: &str) -> Result<ReconcileResult> {
-        let mut clusters = self.clusters.write()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire write lock on clusters".into()))?;
-        let cluster = clusters.get_mut(key)
+        let mut clusters = self.clusters.write().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire write lock on clusters".into())
+        })?;
+        let cluster = clusters
+            .get_mut(key)
             .ok_or_else(|| VecStoreError::NotFound(format!("Cluster {} not found", key)))?;
 
         // Check if deletion is requested
@@ -454,9 +480,12 @@ impl VecStoreOperator {
 
         // Check HA configuration
         if let Some(ref ha) = cluster.spec.ha_config
-            && ha.auto_failover && cluster.status.leader.is_none() && cluster.status.ready_replicas > 0 {
-                actions.push(ReconcileAction::ElectLeader);
-            }
+            && ha.auto_failover
+            && cluster.status.leader.is_none()
+            && cluster.status.ready_replicas > 0
+        {
+            actions.push(ReconcileAction::ElectLeader);
+        }
 
         // Check backup schedule (Rust 1.92 if-let chain)
         if let Some(ref backup) = cluster.spec.backup
@@ -478,48 +507,72 @@ impl VecStoreOperator {
                 cluster.status.ready_replicas += count;
                 cluster.status.phase = ClusterPhase::Running;
 
-                self.add_condition(cluster, ConditionType::ScalingUp, true,
-                    "ScalingUp", &format!("Scaling up by {} replicas", count));
-            }
+                self.add_condition(
+                    cluster,
+                    ConditionType::ScalingUp,
+                    true,
+                    "ScalingUp",
+                    &format!("Scaling up by {} replicas", count),
+                );
+            },
             ReconcileAction::ScaleDown { count } => {
                 cluster.status.phase = ClusterPhase::Scaling;
                 cluster.status.total_replicas -= count;
                 cluster.status.ready_replicas -= count;
                 cluster.status.phase = ClusterPhase::Running;
 
-                self.add_condition(cluster, ConditionType::ScalingDown, true,
-                    "ScalingDown", &format!("Scaling down by {} replicas", count));
-            }
+                self.add_condition(
+                    cluster,
+                    ConditionType::ScalingDown,
+                    true,
+                    "ScalingDown",
+                    &format!("Scaling down by {} replicas", count),
+                );
+            },
             ReconcileAction::UpdateConfig => {
                 cluster.status.phase = ClusterPhase::Updating;
                 // In real operator: rolling update of pods
                 cluster.status.phase = ClusterPhase::Running;
 
-                self.add_condition(cluster, ConditionType::Progressing, true,
-                    "ConfigUpdated", "Configuration updated successfully");
-            }
+                self.add_condition(
+                    cluster,
+                    ConditionType::Progressing,
+                    true,
+                    "ConfigUpdated",
+                    "Configuration updated successfully",
+                );
+            },
             ReconcileAction::ElectLeader => {
                 // Simple leader election (in real operator: use Raft or lease)
                 cluster.status.leader = Some(format!("{}-0", cluster.name));
 
-                self.add_condition(cluster, ConditionType::Ready, true,
-                    "LeaderElected", "Leader election completed");
-            }
+                self.add_condition(
+                    cluster,
+                    ConditionType::Ready,
+                    true,
+                    "LeaderElected",
+                    "Leader election completed",
+                );
+            },
             ReconcileAction::TriggerBackup => {
                 // In real operator: create backup job
                 cluster.status.last_backup = Some(chrono::Utc::now().to_rfc3339());
 
-                self.add_condition(cluster, ConditionType::BackupReady, true,
-                    "BackupCompleted", "Backup completed successfully");
-            }
+                self.add_condition(
+                    cluster,
+                    ConditionType::BackupReady,
+                    true,
+                    "BackupCompleted",
+                    "Backup completed successfully",
+                );
+            },
             ReconcileAction::Repair { reason } => {
                 cluster.status.phase = ClusterPhase::Updating;
                 // In real operator: repair degraded pods
                 cluster.status.phase = ClusterPhase::Running;
 
-                self.add_condition(cluster, ConditionType::Degraded, false,
-                    "Repaired", reason);
-            }
+                self.add_condition(cluster, ConditionType::Degraded, false, "Repaired", reason);
+            },
         }
 
         Ok(())
@@ -543,19 +596,29 @@ impl VecStoreOperator {
 
     fn backup_due(&self, cluster: &ManagedCluster) -> bool {
         if let Some(ref last) = cluster.status.last_backup
-            && let Ok(last_time) = chrono::DateTime::parse_from_rfc3339(last) {
-                let now = chrono::Utc::now();
-                let elapsed = now.signed_duration_since(last_time);
-                // Simple check: backup if more than 24 hours
-                return elapsed.num_hours() >= 24;
-            }
+            && let Ok(last_time) = chrono::DateTime::parse_from_rfc3339(last)
+        {
+            let now = chrono::Utc::now();
+            let elapsed = now.signed_duration_since(last_time);
+            // Simple check: backup if more than 24 hours
+            return elapsed.num_hours() >= 24;
+        }
         true // No backup yet
     }
 
-    fn add_condition(&self, cluster: &mut ManagedCluster, ctype: ConditionType,
-                     status: bool, reason: &str, message: &str) {
+    fn add_condition(
+        &self,
+        cluster: &mut ManagedCluster,
+        ctype: ConditionType,
+        status: bool,
+        reason: &str,
+        message: &str,
+    ) {
         // Remove existing condition of same type
-        cluster.status.conditions.retain(|c| c.condition_type != ctype);
+        cluster
+            .status
+            .conditions
+            .retain(|c| c.condition_type != ctype);
 
         cluster.status.conditions.push(ClusterCondition {
             condition_type: ctype,
@@ -569,14 +632,20 @@ impl VecStoreOperator {
     /// Get cluster status
     pub fn get_status(&self, name: &str, namespace: &str) -> Option<VecStoreClusterStatus> {
         let key = format!("{}/{}", namespace, name);
-        let Ok(clusters) = self.clusters.read() else { return None; };
+        let Ok(clusters) = self.clusters.read() else {
+            return None;
+        };
         clusters.get(&key).map(|c| c.status.clone())
     }
 
     /// List all managed clusters
     pub fn list_clusters(&self) -> Vec<(String, String, VecStoreClusterStatus)> {
-        let Ok(clusters) = self.clusters.read() else { return Vec::new(); };
-        clusters.values().map(|c| (c.namespace.clone(), c.name.clone(), c.status.clone()))
+        let Ok(clusters) = self.clusters.read() else {
+            return Vec::new();
+        };
+        clusters
+            .values()
+            .map(|c| (c.namespace.clone(), c.name.clone(), c.status.clone()))
             .collect()
     }
 
@@ -735,12 +804,14 @@ spec:
     kind: VecStoreCluster
     shortNames:
       - vsc
-"#.to_string()
+"#
+        .to_string()
     }
 
     /// Generate StatefulSet manifest for a cluster
     pub fn generate_statefulset(spec: &VecStoreClusterSpec, name: &str, namespace: &str) -> String {
-        format!(r#"apiVersion: apps/v1
+        format!(
+            r#"apiVersion: apps/v1
 kind: StatefulSet
 metadata:
   name: {name}
@@ -827,7 +898,8 @@ spec:
 
     /// Generate headless service manifest
     pub fn generate_headless_service(name: &str, namespace: &str) -> String {
-        format!(r#"apiVersion: v1
+        format!(
+            r#"apiVersion: v1
 kind: Service
 metadata:
   name: {name}-headless
@@ -853,7 +925,8 @@ spec:
 
     /// Generate client service manifest
     pub fn generate_client_service(name: &str, namespace: &str) -> String {
-        format!(r#"apiVersion: v1
+        format!(
+            r#"apiVersion: v1
 kind: Service
 metadata:
   name: {name}
@@ -882,7 +955,8 @@ spec:
     /// Generate HPA manifest
     pub fn generate_hpa(spec: &VecStoreClusterSpec, name: &str, namespace: &str) -> Option<String> {
         spec.autoscaling.as_ref().map(|autoscaling| {
-            format!(r#"apiVersion: autoscaling/v2
+            format!(
+                r#"apiVersion: autoscaling/v2
 kind: HorizontalPodAutoscaler
 metadata:
   name: {name}
@@ -918,7 +992,8 @@ spec:
     /// Generate PodDisruptionBudget manifest
     pub fn generate_pdb(spec: &VecStoreClusterSpec, name: &str, namespace: &str) -> Option<String> {
         spec.ha_config.as_ref().map(|ha| {
-            format!(r#"apiVersion: policy/v1
+            format!(
+                r#"apiVersion: policy/v1
 kind: PodDisruptionBudget
 metadata:
   name: {name}
@@ -939,7 +1014,8 @@ spec:
 
     /// Generate ServiceMonitor for Prometheus
     pub fn generate_service_monitor(name: &str, namespace: &str) -> String {
-        format!(r#"apiVersion: monitoring.coreos.com/v1
+        format!(
+            r#"apiVersion: monitoring.coreos.com/v1
 kind: ServiceMonitor
 metadata:
   name: {name}
@@ -1067,12 +1143,14 @@ securityContext:
 nodeSelector: {}
 tolerations: []
 affinity: {}
-"#.to_string()
+"#
+        .to_string()
     }
 
     /// Generate Chart.yaml
     pub fn generate_chart() -> String {
-        format!(r#"apiVersion: v2
+        format!(
+            r#"apiVersion: v2
 name: vecstore
 description: A Helm chart for VecStore vector database
 type: application
@@ -1090,7 +1168,9 @@ sources:
 maintainers:
   - name: VecStore Team
     email: team@vecstore.io
-"#, env!("CARGO_PKG_VERSION"))
+"#,
+            env!("CARGO_PKG_VERSION")
+        )
     }
 }
 
@@ -1141,7 +1221,9 @@ mod tests {
         let operator = VecStoreOperator::new(OperatorConfig::default());
         let spec = test_spec();
 
-        operator.handle_create("test-cluster", "default", spec).unwrap();
+        operator
+            .handle_create("test-cluster", "default", spec)
+            .unwrap();
 
         let status = operator.get_status("test-cluster", "default").unwrap();
         assert_eq!(status.phase, ClusterPhase::Pending);
@@ -1152,7 +1234,9 @@ mod tests {
         let operator = VecStoreOperator::new(OperatorConfig::default());
         let spec = test_spec();
 
-        operator.handle_create("test-cluster", "default", spec).unwrap();
+        operator
+            .handle_create("test-cluster", "default", spec)
+            .unwrap();
 
         let result = operator.reconcile("test-cluster", "default").unwrap();
         assert!(result.requeue);
diff --git a/src/kafka_connector.rs b/src/kafka_connector.rs
index 38b6e47..81c3651 100644
--- a/src/kafka_connector.rs
+++ b/src/kafka_connector.rs
@@ -35,7 +35,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::Arc;
diff --git a/src/learned_index.rs b/src/learned_index.rs
index ed8540b..8e9f09a 100644
--- a/src/learned_index.rs
+++ b/src/learned_index.rs
@@ -28,9 +28,9 @@
 //! println!("Recommended beam width: {}", params.beam_width);
 //! ```
 
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::time::Duration;
-use serde::{Deserialize, Serialize};
 
 use crate::error::VecStoreError;
 
@@ -210,7 +210,12 @@ impl CostModel {
             &observation.params_used,
             &DataDistribution {
                 count: 0,
-                dimensions: observation.profile.vector.as_ref().map(|v| v.len()).unwrap_or(128),
+                dimensions: observation
+                    .profile
+                    .vector
+                    .as_ref()
+                    .map(|v| v.len())
+                    .unwrap_or(128),
                 centroid: Vec::new(),
                 variance: Vec::new(),
                 intrinsic_dim: 0.0,
@@ -261,7 +266,9 @@ impl RecallPredictor {
             profile.filter_selectivity as f64,
         ];
 
-        let raw: f64 = self.coefficients.iter()
+        let raw: f64 = self
+            .coefficients
+            .iter()
             .zip(features.iter())
             .map(|(c, f)| c * f)
             .sum();
@@ -271,14 +278,22 @@ impl RecallPredictor {
     }
 
     /// Update predictor with observation
-    pub fn update(&mut self, params: &SearchParams, profile: &QueryProfile, actual_recall: f64, learning_rate: f64) {
+    pub fn update(
+        &mut self,
+        params: &SearchParams,
+        profile: &QueryProfile,
+        actual_recall: f64,
+        learning_rate: f64,
+    ) {
         let predicted = self.predict(params, profile);
         let error = actual_recall - predicted;
 
-        let features = [1.0,
+        let features = [
+            1.0,
             params.ef_search as f64,
             params.beam_width as f64,
-            profile.filter_selectivity as f64];
+            profile.filter_selectivity as f64,
+        ];
 
         // Gradient descent update
         for (i, f) in features.iter().enumerate() {
@@ -353,27 +368,43 @@ impl WorkloadAnalyzer {
         for obs in &self.history {
             let key = format!(
                 "k={}_filter={}",
-                if obs.profile.k <= 10 { "small" } else if obs.profile.k <= 100 { "medium" } else { "large" },
+                if obs.profile.k <= 10 {
+                    "small"
+                } else if obs.profile.k <= 100 {
+                    "medium"
+                } else {
+                    "large"
+                },
                 obs.profile.has_filter
             );
             patterns.entry(key).or_default().push(obs);
         }
 
-        let total_time = self.history.last()
-            .and_then(|last| self.history.first().map(|first| {
-                last.timestamp.duration_since(first.timestamp).unwrap_or_default().as_secs_f64()
-            }))
+        let total_time = self
+            .history
+            .last()
+            .and_then(|last| {
+                self.history.first().map(|first| {
+                    last.timestamp
+                        .duration_since(first.timestamp)
+                        .unwrap_or_default()
+                        .as_secs_f64()
+                })
+            })
             .unwrap_or(1.0);
 
-        self.patterns = patterns.into_iter()
+        self.patterns = patterns
+            .into_iter()
             .map(|(name, obs)| {
                 let count = obs.len();
                 let frequency = count as f64 / total_time.max(1.0);
                 let avg_k = obs.iter().map(|o| o.profile.k as f64).sum::<f64>() / count as f64;
-                let filter_pct = obs.iter().filter(|o| o.profile.has_filter).count() as f64 / count as f64;
+                let filter_pct =
+                    obs.iter().filter(|o| o.profile.has_filter).count() as f64 / count as f64;
 
                 // Find best params (lowest latency meeting recall target)
-                let best = obs.iter()
+                let best = obs
+                    .iter()
                     .filter(|o| o.recall.unwrap_or(1.0) >= 0.9)
                     .min_by(|a, b| a.latency_ms.partial_cmp(&b.latency_ms).unwrap());
 
@@ -399,10 +430,25 @@ impl WorkloadAnalyzer {
         let total = self.history.len();
         let avg_latency = self.history.iter().map(|o| o.latency_ms).sum::<f64>() / total as f64;
         let avg_k = self.history.iter().map(|o| o.profile.k as f64).sum::<f64>() / total as f64;
-        let filter_ratio = self.history.iter().filter(|o| o.profile.has_filter).count() as f64 / total as f64;
-
-        let p50_latency = percentile(&self.history.iter().map(|o| o.latency_ms).collect::<Vec<_>>(), 0.5);
-        let p99_latency = percentile(&self.history.iter().map(|o| o.latency_ms).collect::<Vec<_>>(), 0.99);
+        let filter_ratio =
+            self.history.iter().filter(|o| o.profile.has_filter).count() as f64 / total as f64;
+
+        let p50_latency = percentile(
+            &self
+                .history
+                .iter()
+                .map(|o| o.latency_ms)
+                .collect::<Vec<_>>(),
+            0.5,
+        );
+        let p99_latency = percentile(
+            &self
+                .history
+                .iter()
+                .map(|o| o.latency_ms)
+                .collect::<Vec<_>>(),
+            0.99,
+        );
 
         WorkloadSummary {
             total_queries: total,
@@ -510,7 +556,8 @@ impl LearnedIndex {
 
         // Update models
         if self.config.continuous_learning {
-            self.cost_model.update(&observation, self.config.learning_rate);
+            self.cost_model
+                .update(&observation, self.config.learning_rate);
 
             if let Some(actual_recall) = recall {
                 self.recall_predictor.update(
@@ -675,7 +722,8 @@ impl LearnedIndex {
             let mut min_dist = f32::MAX;
             for (j, v2) in vectors.iter().enumerate() {
                 if i != j {
-                    let dist: f32 = v1.iter()
+                    let dist: f32 = v1
+                        .iter()
                         .zip(v2.iter())
                         .map(|(a, b)| (a - b).powi(2))
                         .sum::<f32>()
@@ -721,9 +769,13 @@ impl LearnedIndex {
         }
 
         // Adjust beam width similarly
-        let avg_recall = self.workload.history.iter()
+        let avg_recall = self
+            .workload
+            .history
+            .iter()
             .filter_map(|o| o.recall)
-            .sum::<f64>() / self.workload.history.len().max(1) as f64;
+            .sum::<f64>()
+            / self.workload.history.len().max(1) as f64;
 
         if avg_recall < self.config.target_recall {
             self.current_params.beam_width = (self.current_params.beam_width as f64 * 1.2) as usize;
@@ -760,7 +812,8 @@ impl LearnedIndex {
         if profile.has_filter && profile.filter_selectivity < 0.5 {
             // Low selectivity = need more candidates
             let mut params = base.clone();
-            params.ef_search = (base.ef_search as f32 / profile.filter_selectivity.max(0.1)) as usize;
+            params.ef_search =
+                (base.ef_search as f32 / profile.filter_selectivity.max(0.1)) as usize;
             params.ef_search = params.ef_search.min(500);
             candidates.push(params);
         }
@@ -814,11 +867,18 @@ pub struct BenchmarkResult {
 impl ParamBenchmark {
     /// Create a new benchmark
     pub fn new() -> Self {
-        Self { results: Vec::new() }
+        Self {
+            results: Vec::new(),
+        }
     }
 
     /// Run benchmark with given parameters
-    pub fn run<F>(&mut self, params: SearchParams, query_fn: F, iterations: usize) -> BenchmarkResult
+    pub fn run<F>(
+        &mut self,
+        params: SearchParams,
+        query_fn: F,
+        iterations: usize,
+    ) -> BenchmarkResult
     where
         F: Fn(&SearchParams) -> (Duration, Option<f64>),
     {
@@ -859,10 +919,17 @@ impl ParamBenchmark {
     }
 
     /// Find best parameters meeting constraints
-    pub fn best_params(&self, min_recall: Option<f64>, max_latency: Option<f64>) -> Option<&BenchmarkResult> {
-        self.results.iter()
+    pub fn best_params(
+        &self,
+        min_recall: Option<f64>,
+        max_latency: Option<f64>,
+    ) -> Option<&BenchmarkResult> {
+        self.results
+            .iter()
             .filter(|r| {
-                let recall_ok = min_recall.map(|mr| r.recall.unwrap_or(1.0) >= mr).unwrap_or(true);
+                let recall_ok = min_recall
+                    .map(|mr| r.recall.unwrap_or(1.0) >= mr)
+                    .unwrap_or(true);
                 let latency_ok = max_latency.map(|ml| r.avg_latency_ms <= ml).unwrap_or(true);
                 recall_ok && latency_ok
             })
@@ -906,7 +973,9 @@ mod tests {
         let mut index = LearnedIndex::new(config);
 
         for i in 0..100 {
-            index.add(format!("v{}", i), vec![i as f32, 0.0, 0.0]).unwrap();
+            index
+                .add(format!("v{}", i), vec![i as f32, 0.0, 0.0])
+                .unwrap();
         }
 
         index.update_distribution();
@@ -930,13 +999,7 @@ mod tests {
             category: None,
         };
 
-        index.observe_query(
-            profile,
-            5.0,
-            Some(0.95),
-            10,
-            SearchParams::default(),
-        );
+        index.observe_query(profile, 5.0, Some(0.95), 10, SearchParams::default());
 
         let summary = index.workload_summary();
         assert_eq!(summary.total_queries, 1);
diff --git a/src/lib.rs b/src/lib.rs
index ee18f4f..8ac449d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -295,65 +295,65 @@ pub mod object_storage;
 pub mod pq;
 
 // 2026 Competitive Features - Phase 2
-pub mod inference;       // Integrated Inference API (embed at query time)
-pub mod sql;             // SQL Interface for vector operations
-pub mod rabitq;          // RaBitQ 1-bit quantization (30x compression)
-pub mod generative;      // Native Generative Search (RAG in single call)
-pub mod llm_cache;       // Semantic LLM Cache (query deduplication)
-pub mod multilang;       // Multi-Language Stemming (17+ languages)
-pub mod typo_tolerance;  // Typo-Tolerant Search (fuzzy matching)
-pub mod graphrag;        // GraphRAG Integration (knowledge graphs)
-pub mod streaming;       // Streaming Index Updates (real-time)
-pub mod edge_runtime;    // Edge Runtime (Workers/Vercel)
-pub mod ml_ranking;      // ONNX/ML Models in Ranking
+pub mod edge_runtime; // Edge Runtime (Workers/Vercel)
+pub mod generative; // Native Generative Search (RAG in single call)
+pub mod graphrag; // GraphRAG Integration (knowledge graphs)
+pub mod inference; // Integrated Inference API (embed at query time)
+pub mod llm_cache; // Semantic LLM Cache (query deduplication)
+pub mod ml_ranking;
+pub mod multilang; // Multi-Language Stemming (17+ languages)
+pub mod rabitq; // RaBitQ 1-bit quantization (30x compression)
+pub mod sql; // SQL Interface for vector operations
+pub mod streaming; // Streaming Index Updates (real-time)
+pub mod typo_tolerance; // Typo-Tolerant Search (fuzzy matching) // ONNX/ML Models in Ranking
 
 // 2026 Competitive Features - Phase 3 (Market Domination)
-pub mod sparse_native;   // Native SPLADE/BM25 sparse vectors
-pub mod serverless;      // Pinecone-style auto-scaling
-pub mod timetravel;      // Milvus-style point-in-time queries
-pub mod payload_index;   // Qdrant-style B-tree/Hash/Geo indexes
-pub mod partition_keys;  // Multi-tenant partition routing
-pub mod graphql_api;     // Weaviate-style GraphQL interface
+pub mod dynamic_schema; // Runtime schema flexibility
+pub mod embedded_onnx;
+pub mod graphql_api; // Weaviate-style GraphQL interface
+pub mod partition_keys; // Multi-tenant partition routing
+pub mod payload_index; // Qdrant-style B-tree/Hash/Geo indexes
 pub mod recommendations; // Item-to-item recommendations
-pub mod zero_copy;       // LanceDB-style versioning
-pub mod dynamic_schema;  // Runtime schema flexibility
-pub mod embedded_onnx;   // Chroma-style local embeddings
+pub mod serverless; // Pinecone-style auto-scaling
+pub mod sparse_native; // Native SPLADE/BM25 sparse vectors
+pub mod timetravel; // Milvus-style point-in-time queries
+pub mod zero_copy; // LanceDB-style versioning // Chroma-style local embeddings
 
 // 2026 Competitive Features - Phase 4 (Market Leadership)
-pub mod agentic;            // Agentic Query Framework (multi-step retrieval)
-pub mod object_store;       // Object Storage Backend (S3/GCS, 100x cost reduction)
-pub mod hybrid_rerank;      // Hybrid Reranking Pipeline (dense+sparse+BM25)
-pub mod managed_embeddings; // Managed Embedding Service (pay-as-you-go)
-pub mod advanced_quant;     // Advanced Quantization (1.5-bit, 2-bit, asymmetric)
-pub mod multimodal_search;  // Multimodal Search (text↔image↔video)
+pub mod advanced_quant; // Advanced Quantization (1.5-bit, 2-bit, asymmetric)
+pub mod agentic; // Agentic Query Framework (multi-step retrieval)
+pub mod change_streams; // Change Streams (real-time subscriptions)
+pub mod discovery; // Discovery API (vector-space exploration)
 pub mod enterprise_protect; // Enterprise Protection (CMEK, backup/restore)
-pub mod discovery;          // Discovery API (vector-space exploration)
-pub mod change_streams;     // Change Streams (real-time subscriptions)
-pub mod gpu_indexing;       // GPU Index Building (10x faster ingestion)
+pub mod gpu_indexing;
+pub mod hybrid_rerank; // Hybrid Reranking Pipeline (dense+sparse+BM25)
+pub mod managed_embeddings; // Managed Embedding Service (pay-as-you-go)
+pub mod multimodal_search; // Multimodal Search (text↔image↔video)
+pub mod object_store; // Object Storage Backend (S3/GCS, 100x cost reduction) // GPU Index Building (10x faster ingestion)
 
 // 2026 Competitive Features - Phase 5 (Production Readiness)
-pub mod otel;            // OpenTelemetry OTLP Export (distributed tracing)
-pub mod query_explain;   // Visual Query Explain (EXPLAIN ANALYZE)
-pub mod adaptive_cache;  // Multi-Tier Adaptive Cache (L1/L2/L3)
-pub mod backpressure;    // Streaming Backpressure (flow control)
-pub mod rest_api;        // REST API with OpenAPI (spec generation)
-pub mod raft_consensus;  // Production Raft Consensus (leader election)
-pub mod sdk_gen;         // Multi-Language SDK Generation (TS/Python/Go)
+pub mod adaptive_cache; // Multi-Tier Adaptive Cache (L1/L2/L3)
+pub mod backpressure; // Streaming Backpressure (flow control)
+pub mod otel; // OpenTelemetry OTLP Export (distributed tracing)
+pub mod query_explain; // Visual Query Explain (EXPLAIN ANALYZE)
+pub mod raft_consensus; // Production Raft Consensus (leader election)
+pub mod rest_api; // REST API with OpenAPI (spec generation)
+pub mod sdk_gen; // Multi-Language SDK Generation (TS/Python/Go)
 
 // 2026 Competitive Features - Phase 6 (Cloud-Native Operations)
-pub mod k8s_operator;      // Kubernetes Operator (CRD, Helm charts)
-pub mod query_router;      // Query Router / Load Balancer (circuit breaker)
-pub mod data_lineage;      // Data Lineage Tracking (provenance, impact analysis)
-pub mod ab_testing;        // A/B Testing Framework (experiments, variants)
+pub mod ab_testing; // A/B Testing Framework (experiments, variants)
+pub mod data_lineage; // Data Lineage Tracking (provenance, impact analysis)
+pub mod federation;
 pub mod incremental_index; // Incremental Index Updates (delta indexes, WAL)
-pub mod federation;        // Federation (cross-store queries, multi-cluster)
+pub mod k8s_operator; // Kubernetes Operator (CRD, Helm charts)
+pub mod query_router; // Query Router / Load Balancer (circuit breaker) // Federation (cross-store queries, multi-cluster)
 
 // 2026 Competitive Features - Phase 7 (Advanced Analytics & ML)
-pub mod neural_ranker;     // Neural Ranker (cross-encoder, late interaction, SPLADE)
-pub mod auto_tuning;       // Auto-Tuning Engine (Bayesian optimization, hyperparameter search)
 pub mod anomaly_detection; // Anomaly Detection (isolation forest, LOF, drift monitoring)
-pub mod query_analytics;   // Query Analytics Dashboard (performance insights, trends)
-pub mod cost_optimizer;    // Cost Optimizer (resource right-sizing, auto-scaling)
+pub mod auto_tuning; // Auto-Tuning Engine (Bayesian optimization, hyperparameter search)
+pub mod cost_optimizer;
+pub mod neural_ranker; // Neural Ranker (cross-encoder, late interaction, SPLADE)
+pub mod query_analytics; // Query Analytics Dashboard (performance insights, trends) // Cost Optimizer (resource right-sizing, auto-scaling)
 
 #[cfg(feature = "async")]
 pub mod kafka_connector;
@@ -368,11 +368,11 @@ pub use namespace::{Namespace, NamespaceId, NamespaceQuotas, NamespaceStatus, Re
 pub use namespace_manager::{AggregateStats, NamespaceManager, NamespaceStats};
 pub use schema::{FieldSchema, FieldType, Schema, ValidationError};
 pub use store::{
-    make_record, parse_filter, BatchError, BatchOperation, BatchResult, CompactionConfig,
-    CompactionResult, Config, Distance, ExplainedNeighbor, FilterExpr, FilterOp, FilterParseError,
-    HNSWSearchParams, HybridQuery, Metadata, Neighbor, PQConfig, PQVectorStore, PrefetchQuery,
-    ProductQuantizer, QuantizationConfig, QuantizationStats, Query, QueryEstimate, QueryExplanation,
-    QueryPlan, QueryStage, QueryStep, Record, VecStore, VecStoreBuilder,
+    BatchError, BatchOperation, BatchResult, CompactionConfig, CompactionResult, Config, Distance,
+    ExplainedNeighbor, FilterExpr, FilterOp, FilterParseError, HNSWSearchParams, HybridQuery,
+    Metadata, Neighbor, PQConfig, PQVectorStore, PrefetchQuery, ProductQuantizer,
+    QuantizationConfig, QuantizationStats, Query, QueryEstimate, QueryExplanation, QueryPlan,
+    QueryStage, QueryStep, Record, VecStore, VecStoreBuilder, make_record, parse_filter,
 };
 pub use text_splitter::{
     RecursiveCharacterTextSplitter, TextChunk, TextSplitter, TokenTextSplitter,
@@ -380,8 +380,8 @@ pub use text_splitter::{
 
 // Export fuzzy search types
 pub use fuzzy::{
-    damerau_levenshtein_distance, levenshtein_distance, similarity_score, suggest_corrections,
-    BKTree, FuzzyMatcher,
+    BKTree, FuzzyMatcher, damerau_levenshtein_distance, levenshtein_distance, similarity_score,
+    suggest_corrections,
 };
 
 // Export auto-tuning types
@@ -389,8 +389,8 @@ pub use autotuning::{AutoTuner, HnswParams, PerformanceConstraints, TuningGoal};
 
 // Export compression types
 pub use compression::{
-    decode_rle, decode_varint, encode_rle, encode_varint, CompressedNeighborList,
-    CompressionConfig, CompressionLevel, CompressionMethod, CompressionStats,
+    CompressedNeighborList, CompressionConfig, CompressionLevel, CompressionMethod,
+    CompressionStats, decode_rle, decode_varint, encode_rle, encode_varint,
 };
 
 // Export real-time indexing types
@@ -453,8 +453,9 @@ pub use benchmark::{
 
 // Export health check types
 pub use health::{
-    print_health_report, Alert, AlertCategory, AlertSeverity, DatabaseHealth, HealthCheckConfig,
-    HealthChecker, HealthReport, HealthStatus, IndexHealth, PerformanceHealth, ResourceHealth,
+    Alert, AlertCategory, AlertSeverity, DatabaseHealth, HealthCheckConfig, HealthChecker,
+    HealthReport, HealthStatus, IndexHealth, PerformanceHealth, ResourceHealth,
+    print_health_report,
 };
 
 // Export metadata indexing types
@@ -485,7 +486,7 @@ pub use anomaly::{
 };
 
 // Export dimensionality reduction types
-pub use dim_reduction::{ReductionStats, PCA};
+pub use dim_reduction::{PCA, ReductionStats};
 
 // Export recommender system types
 pub use recommender::{
@@ -560,7 +561,7 @@ pub use geospatial::{
 };
 
 // Export advanced filter types
-pub use advanced_filter::{parse_advanced_filter, AdvancedFilter, FilterBuilder};
+pub use advanced_filter::{AdvancedFilter, FilterBuilder, parse_advanced_filter};
 
 // Export profiler types
 pub use profiler::{ProfileStage, ProfileSummary, ProfilerConfig, QueryProfile, QueryProfiler};
@@ -568,9 +569,8 @@ pub use profiler::{ProfileStage, ProfileSummary, ProfilerConfig, QueryProfile, Q
 #[cfg(feature = "async")]
 // Export Kafka connector types
 pub use kafka_connector::{
-    ConsumerStats, KafkaConfig, KafkaConsumer, KafkaProducer,
-    Operation as KafkaOperation, PipelineStats as KafkaPipelineStats,
-    ProducerStats, StreamingPipeline, VectorMessage,
+    ConsumerStats, KafkaConfig, KafkaConsumer, KafkaProducer, Operation as KafkaOperation,
+    PipelineStats as KafkaPipelineStats, ProducerStats, StreamingPipeline, VectorMessage,
 };
 
 #[cfg(feature = "async")]
@@ -579,9 +579,9 @@ pub use python_async::{AsyncPyVecStore, AsyncSearchResult};
 
 // Export vectors module types
 pub use vectors::{
-    bm25_score, bm25_score_simple, hybrid_search_score, normalize_scores, normalize_scores_zscore,
     BM25Config, BM25Stats, FusionStrategy, HybridQuery as HybridQueryV2, HybridSearchConfig,
-    KMeans, Vector, VectorOps,
+    KMeans, Vector, VectorOps, bm25_score, bm25_score_simple, hybrid_search_score,
+    normalize_scores, normalize_scores_zscore,
 };
 
 // Export SIMD-accelerated distance functions
@@ -613,114 +613,122 @@ pub use embeddings::{CandleEmbedder, CandleModel};
 pub use wasm::{WasmSearchResult, WasmVecStore};
 
 // Export 2026 Competitive Features - Phase 2
-pub use inference::{EmbeddingProvider, InferenceConfig, InferenceEngine, InferenceStats};
-pub use sql::{DataType, Row, TableSchema, VectorSQL};
-pub use rabitq::{BinaryCode, RaBitQ, RaBitQConfig, RaBitQIndex};
+pub use edge_runtime::{EdgeConfig, EdgeSearchResult, EdgeVectorStore};
 pub use generative::{
     Citation, GenerativeConfig, GenerativeResponse, GenerativeSearch, LLMProvider,
     RetrievedDocument, TokenUsage,
 };
-pub use llm_cache::{CacheConfig, CacheResult, SemanticCache};
-pub use multilang::{AutoLangAnalyzer, Language, MultiLangAnalyzer};
-pub use typo_tolerance::{MatchType, TypoConfig, TypoSearchResult, TypoTolerantSearch};
 pub use graphrag::{Entity as GraphEntity, GraphRAG as GraphRAGV2, Relationship};
-pub use streaming::{ConflictStrategy, StreamConfig, StreamingIndex, StreamingStats};
-pub use edge_runtime::{EdgeConfig, EdgeSearchResult, EdgeVectorStore};
+pub use inference::{EmbeddingProvider, InferenceConfig, InferenceEngine, InferenceStats};
+pub use llm_cache::{CacheConfig, CacheResult, SemanticCache};
 pub use ml_ranking::{
     MLRanker, RankedResult, RankingCandidate, RankingConfig, RankingFeatures, RankingModel,
     RankingPipeline, RankingStage,
 };
+pub use multilang::{AutoLangAnalyzer, Language, MultiLangAnalyzer};
+pub use rabitq::{BinaryCode, RaBitQ, RaBitQConfig, RaBitQIndex};
+pub use sql::{DataType, Row, TableSchema, VectorSQL};
+pub use streaming::{ConflictStrategy, StreamConfig, StreamingIndex, StreamingStats};
+pub use typo_tolerance::{MatchType, TypoConfig, TypoSearchResult, TypoTolerantSearch};
 
 // Export 2026 Competitive Features - Phase 3 (Market Domination)
-pub use sparse_native::{
-    HybridSparseIndex, InvertedSparseIndex, SparseVector as NativeSparseVector,
-    SpladeEncoder as NativeSpladeEncoder,
-};
-pub use serverless::{
-    Autoscaler, ColdStartOptimizer, LoadBalancer, ReplicaInfo, ServerlessCluster, ServerlessConfig,
-    ServerlessStats,
-};
-pub use timetravel::{
-    SnapshotManager, TimeTravelIndex, TimeTravelResult, Timestamp, VersionEntry,
-    VersionHistory as TimeTravelVersionHistory,
+pub use dynamic_schema::{
+    DynamicCollection, FieldDef, FieldType as DynamicFieldType, Schema as DynamicSchema,
+    SchemaBuilder, SchemaChange, SchemaEvolution,
 };
-pub use payload_index::{
-    Filter, GeoIndex as PayloadGeoIndex, GeoPoint as PayloadGeoPoint, HashIndex as PayloadHashIndex,
-    BTreeIndex as PayloadBTreeIndex, FullTextIndex, PayloadIndexManager, IndexType as PayloadIndexType,
+pub use embedded_onnx::{EmbeddedStore, EmbeddingFunction, EmbeddingModel, ModelConfig, ModelType};
+pub use graphql_api::{
+    GqlCollection, GqlField, GqlType, GraphQLExecutor, NearTextInput, NearVectorInput, VectorQuery,
+    WhereFilter, WhereOperator,
 };
 pub use partition_keys::{
     HashAlgorithm, Partition, PartitionConfig as PartitionKeyConfig, PartitionRouter,
-    PartitionedIndex, PartitionState,
+    PartitionState, PartitionedIndex,
 };
-pub use graphql_api::{
-    GqlCollection, GqlField, GqlType, GraphQLExecutor, NearTextInput, NearVectorInput, VectorQuery,
-    WhereFilter, WhereOperator,
+pub use payload_index::{
+    BTreeIndex as PayloadBTreeIndex, Filter, FullTextIndex, GeoIndex as PayloadGeoIndex,
+    GeoPoint as PayloadGeoPoint, HashIndex as PayloadHashIndex, IndexType as PayloadIndexType,
+    PayloadIndexManager,
 };
 pub use recommendations::{
     RecommendRequest, RecommendResult, RecommendStrategy, RecommendationEngine,
     UserProfile as RecommendUserProfile,
 };
-pub use zero_copy::{
-    Branch, BranchName, Commit, CommitHash, Diff, MergeResult, VersionedStore as CowVersionedStore,
+pub use serverless::{
+    Autoscaler, ColdStartOptimizer, LoadBalancer, ReplicaInfo, ServerlessCluster, ServerlessConfig,
+    ServerlessStats,
 };
-pub use dynamic_schema::{
-    DynamicCollection, FieldDef, FieldType as DynamicFieldType, Schema as DynamicSchema,
-    SchemaBuilder, SchemaChange, SchemaEvolution,
+pub use sparse_native::{
+    HybridSparseIndex, InvertedSparseIndex, SparseVector as NativeSparseVector,
+    SpladeEncoder as NativeSpladeEncoder,
+};
+pub use timetravel::{
+    SnapshotManager, TimeTravelIndex, TimeTravelResult, Timestamp, VersionEntry,
+    VersionHistory as TimeTravelVersionHistory,
 };
-pub use embedded_onnx::{
-    EmbeddedStore, EmbeddingFunction, EmbeddingModel, ModelConfig, ModelType,
+pub use zero_copy::{
+    Branch, BranchName, Commit, CommitHash, Diff, MergeResult, VersionedStore as CowVersionedStore,
 };
 
 // Export 2026 Competitive Features - Phase 4 (Market Leadership)
+pub use advanced_quant::{
+    AdaptiveQuantizer, AsymmetricQuantizer, BinaryQuantizer as AdvancedBinaryQuantizer, BitWidth,
+    FourBitQuantizer, QuantConfig, QuantParams, QuantStrategy, QuantizedIndex, QuantizedIndexStats,
+    QuantizedVector, TernaryQuantizer, TwoBitQuantizer,
+};
 pub use agentic::{
-    AgentConfig, AgentExecutor, AgentExecutionResult, AgentState, AgentStats,
+    AgentConfig, AgentExecutionResult, AgentExecutor, AgentState, AgentStats,
     DecompositionStrategy, FusedResult, FusionStrategy as AgenticFusionStrategy,
     QueryPlan as AgenticQueryPlan, QueryPlanner, SubQuery, ToolCall, ToolDefinition, ToolResult,
 };
-pub use object_store::{
-    CacheStats, CacheTier, CostEstimate, ObjectMetadata, ObjectStoreBackend, ObjectStoreConfig,
-    ObjectStoreStats, PreWarmingConfig, PreWarmStrategy, StorageProvider, StoredVector,
-    TieredStorageManager, TieredStorageStats,
+pub use change_streams::{
+    ChangeEvent, ChangeFilter, ChangeMetadata, ChangeSource, ChangeStream, ChangeStreamManager,
+    ChangeStreamStats, DocumentSnapshot, Operation, ResumeToken, Subscription,
+};
+pub use discovery::{
+    DiscoveryConfig, DiscoveryIndex, DiscoveryMode, DiscoveryQuery, DiscoveryResult,
+    DiscoveryStats, ExplorationResult, Region,
+};
+pub use enterprise_protect::{
+    BackupConfig, BackupManager, BackupMetadata, BackupStats, CMEKConfig, ComplianceChecker,
+    ComplianceFramework, ComplianceStatus, ComplianceSummary, EncryptedData, EncryptionManager,
+    EnterpriseConfig, KMSProvider, KeyRotationResult, RetentionAction, RetentionPolicy,
+};
+pub use gpu_indexing::{
+    BuildStats, GpuBackendType, GpuConfig as GpuIndexConfig, GpuDeviceInfo as GpuIndexDeviceInfo,
+    GpuDistanceMetric, GpuHnswIndex, GpuIndexBuilder, GpuIndexStats, HnswParams as GpuHnswParams,
+    MemoryPoolStats,
 };
 pub use hybrid_rerank::{
     BooleanQuery, FusionMethod, HybridConfig, HybridDocument, HybridPipeline, HybridResult,
-    HybridSearchQuery, PipelineStats, RerankerConfig, RerankerType, ScoreExplanation,
-    SignalType, SparseQueryVector,
+    HybridSearchQuery, PipelineStats, RerankerConfig, RerankerType, ScoreExplanation, SignalType,
+    SparseQueryVector,
 };
 pub use managed_embeddings::{
-    EmbeddingCollection as ManagedEmbeddingCollection, EmbeddingProvider as ManagedEmbeddingProvider, EmbeddingRequest,
-    EmbeddingResponse, EmbeddingService, EmbeddingServiceConfig,
-    ModelConfig as EmbeddingModelConfig, QueryResult as EmbeddingQueryResult, TaskType, UsageStats,
-};
-pub use advanced_quant::{
-    AdaptiveQuantizer, AsymmetricQuantizer, BinaryQuantizer as AdvancedBinaryQuantizer,
-    BitWidth, FourBitQuantizer, QuantConfig, QuantizedIndex, QuantizedIndexStats,
-    QuantizedVector, QuantParams, QuantStrategy, TernaryQuantizer, TwoBitQuantizer,
+    EmbeddingCollection as ManagedEmbeddingCollection,
+    EmbeddingProvider as ManagedEmbeddingProvider, EmbeddingRequest, EmbeddingResponse,
+    EmbeddingService, EmbeddingServiceConfig, ModelConfig as EmbeddingModelConfig,
+    QueryResult as EmbeddingQueryResult, TaskType, UsageStats,
 };
 pub use multimodal_search::{
     Modality as SearchModality, MultimodalConfig, MultimodalDocument, MultimodalIndex,
     MultimodalQuery, MultimodalResult, MultimodalStats,
 };
-pub use enterprise_protect::{
-    BackupConfig, BackupManager, BackupMetadata, BackupStats, CMEKConfig, ComplianceChecker,
-    ComplianceFramework, ComplianceStatus, ComplianceSummary, EncryptedData, EncryptionManager,
-    EnterpriseConfig, KMSProvider, KeyRotationResult, RetentionAction, RetentionPolicy,
-};
-pub use discovery::{
-    DiscoveryConfig, DiscoveryIndex, DiscoveryMode, DiscoveryQuery, DiscoveryResult,
-    DiscoveryStats, ExplorationResult, Region,
-};
-pub use change_streams::{
-    ChangeEvent, ChangeFilter, ChangeMetadata, ChangeSource, ChangeStream, ChangeStreamManager,
-    ChangeStreamStats, DocumentSnapshot, Operation, ResumeToken, Subscription,
-};
-pub use gpu_indexing::{
-    BuildStats, GpuBackendType, GpuConfig as GpuIndexConfig, GpuDeviceInfo as GpuIndexDeviceInfo,
-    GpuDistanceMetric, GpuHnswIndex, GpuIndexBuilder, GpuIndexStats,
-    HnswParams as GpuHnswParams, MemoryPoolStats,
+pub use object_store::{
+    CacheStats, CacheTier, CostEstimate, ObjectMetadata, ObjectStoreBackend, ObjectStoreConfig,
+    ObjectStoreStats, PreWarmStrategy, PreWarmingConfig, StorageProvider, StoredVector,
+    TieredStorageManager, TieredStorageStats,
 };
 
 // Export 2026 Competitive Features - Phase 5 (Production Readiness)
+pub use adaptive_cache::{
+    AdaptiveCache, BloomFilter, CacheConfig as AdaptiveCacheConfig, CacheEntry, CacheKeyGenerator,
+    CacheStats as AdaptiveCacheStats, CachedResult, TierStats,
+};
+pub use backpressure::{
+    BackpressureController, BackpressureState, BatchProcessor, Checkpoint, DeadLetterRecord,
+    LagMetrics, StreamConfig as BackpressureStreamConfig, StreamRecord, StreamStats,
+};
 pub use otel::{
     BatchConfig as OtelBatchConfig, ExporterType, MetricPoint as OtelMetricPoint,
     MetricType as OtelMetricType, OtelConfig, OtlpExportData, OtlpSpan, SamplingStrategy,
@@ -731,91 +739,90 @@ pub use query_explain::{
     ExecutionStats, ExplainFormat, ExplainOptions, ExplainResult, IndexStats as ExplainIndexStats,
     OptimizationSuggestion, PlanNode, PlanNodeType, QueryExplainer, SuggestionType,
 };
-pub use adaptive_cache::{
-    AdaptiveCache, BloomFilter, CacheConfig as AdaptiveCacheConfig, CacheEntry,
-    CacheKeyGenerator, CacheStats as AdaptiveCacheStats, CachedResult, TierStats,
-};
-pub use backpressure::{
-    BackpressureController, BackpressureState, BatchProcessor, Checkpoint,
-    DeadLetterRecord, LagMetrics, StreamConfig as BackpressureStreamConfig, StreamRecord,
-    StreamStats,
-};
-pub use rest_api::{
-    ApiInfo, ApiRateLimiter, HttpMethod, OpenApiGenerator, Request as RestRequest,
-    Response as RestResponse, RestConfig, Route as RestRoute, Router as RestRouter,
-};
 pub use raft_consensus::{
     AppendEntriesRequest, AppendEntriesResponse, ClusterStatus, EntryType, InstallSnapshotRequest,
     LeaderState, LogEntry, PersistentState, RaftConfig, RaftError, RaftNode, RaftState,
     SnapshotMetadata, VolatileState, VoteRequest, VoteResponse,
 };
+pub use rest_api::{
+    ApiInfo, ApiRateLimiter, HttpMethod, OpenApiGenerator, Request as RestRequest,
+    Response as RestResponse, RestConfig, Route as RestRoute, Router as RestRouter,
+};
 pub use sdk_gen::{
     FieldDef as SdkFieldDef, FieldType as SdkFieldType, Language as SdkLanguage, MethodDef,
     ParamDef, ParamLocation, SdkGenerator, TypeDef,
 };
 
 // Export 2026 Competitive Features - Phase 6 (Cloud-Native Operations)
-pub use k8s_operator::{
-    AutoscalingConfig, BackupConfig as K8sBackupConfig, ClusterCondition, ClusterPhase,
-    ConditionType, DistanceMetric as K8sDistanceMetric, HAConfig, HelmChartGenerator,
-    IndexConfig as K8sIndexConfig, ManifestGenerator, MonitoringConfig as K8sMonitoringConfig,
-    OperatorConfig, OperatorMetricsSnapshot, ReconcileAction, ReconcileResult,
-    ResourceRequirements, ResourceSpec, VecStoreClusterSpec, VecStoreClusterStatus,
-    VecStoreOperator,
-};
-pub use query_router::{
-    CircuitState as RouterCircuitState, FilterComplexity, HealthStatus as RouterHealthStatus,
-    LoadBalanceStrategy, NodeCapabilities, NodeStats, QueryCharacteristics, QueryPriority,
-    QueryRouter, ReplicaNode, RequestContext, RetryConfig, RetryHandler, RouterConfig,
-    RouterStats, RoutingDecision, RoutingReason,
-};
-pub use data_lineage::{
-    AccessRecord, AccessType, DerivationOperation, ImpactReport, LineageConfig,
-    LineageRecord, LineageStats, LineageTracker, QualityMetrics as LineageQualityMetrics,
-    Transformation, TransformationType, VectorId, VectorSource,
-};
 pub use ab_testing::{
     ABTestManager, ABTestStats, ExperimentConfig, ExperimentResults, ExperimentStatus,
     ExperimentSummary, ExperimentType, IndexParams as ABIndexParams, Metric as ABMetric,
-    MetricSummary, MetricType as ABMetricType, RerankingConfig as ABRerankingConfig,
-    RequestResult as ABRequestResult, SearchParams as ABSearchParams, TrafficAllocation,
+    MetricSummary, MetricType as ABMetricType, RequestResult as ABRequestResult,
+    RerankingConfig as ABRerankingConfig, SearchParams as ABSearchParams, TrafficAllocation,
     Variant, VariantAssignment, VariantComparison, VariantConfig, VariantResult,
 };
+pub use data_lineage::{
+    AccessRecord, AccessType, DerivationOperation, ImpactReport, LineageConfig, LineageRecord,
+    LineageStats, LineageTracker, QualityMetrics as LineageQualityMetrics, Transformation,
+    TransformationType, VectorId, VectorSource,
+};
+pub use federation::{
+    FederatedQuery, FederatedQueryResult, FederatedResult, Federation, FederationBuilder,
+    FederationConfig, FederationMember, FederationStatus, MemberCapabilities, MemberHealth,
+    MemberStatus, MemberType, MergeStrategy,
+};
 pub use incremental_index::{
     BatchResult as IncrementalBatchResult, IncrementalConfig, IncrementalIndex,
     IndexStats as IncrementalIndexStats, MergeResult as IncrementalMergeResult,
     Operation as IncrementalOperation, RecoveryResult, SearchResult as IncrementalSearchResult,
     SearchSource, VectorEntry, WalRecovery,
 };
-pub use federation::{
-    FederatedQuery, FederatedQueryResult, FederatedResult, Federation, FederationBuilder,
-    FederationConfig, FederationMember, FederationStatus, MemberCapabilities, MemberHealth,
-    MemberStatus, MemberType, MergeStrategy,
+pub use k8s_operator::{
+    AutoscalingConfig, BackupConfig as K8sBackupConfig, ClusterCondition, ClusterPhase,
+    ConditionType, DistanceMetric as K8sDistanceMetric, HAConfig, HelmChartGenerator,
+    IndexConfig as K8sIndexConfig, ManifestGenerator, MonitoringConfig as K8sMonitoringConfig,
+    OperatorConfig, OperatorMetricsSnapshot, ReconcileAction, ReconcileResult,
+    ResourceRequirements, ResourceSpec, VecStoreClusterSpec, VecStoreClusterStatus,
+    VecStoreOperator,
+};
+pub use query_router::{
+    CircuitState as RouterCircuitState, FilterComplexity, HealthStatus as RouterHealthStatus,
+    LoadBalanceStrategy, NodeCapabilities, NodeStats, QueryCharacteristics, QueryPriority,
+    QueryRouter, ReplicaNode, RequestContext, RetryConfig, RetryHandler, RouterConfig, RouterStats,
+    RoutingDecision, RoutingReason,
 };
 
 // Phase 7 exports
-pub use neural_ranker::{
-    ActivationFn, CombinationMethod, CrossEncoder, CrossEncoderConfig, EnsembleConfig,
-    EnsembleRanker, LateInteractionConfig, LateInteractionModel, LearnedSparseConfig,
-    LearnedSparseModel, ModelType as NeuralModelType, NeuralRanker, NeuralRankerBuilder,
-    NeuralRankerConfig, RankerStatsSummary, Ranker as NeuralRankerTrait, RerankCandidate,
-    RerankResponse, RerankResult, SimilarityFn, SparseRepresentation,
+pub use anomaly_detection::{
+    AnomalyConfig, AnomalyDetector as VectorAnomalyDetector,
+    AnomalyDetectorBuilder as VectorAnomalyDetectorBuilder, AnomalyRecord, AnomalyType,
+    BatchDetectionResult, DetectionMethod, DetectionResult, DetectionStats, DetectionSummary,
+    DriftConfig, DriftDetector, DriftEvent, DriftMethod, DriftSeverity,
 };
 pub use auto_tuning::{
     AcquisitionFunction, AutoTuneConfig, AutoTuner as HyperparameterTuner,
     AutoTunerBuilder as HyperparameterTunerBuilder, Constraint as TuneConstraint,
     ConstraintType as TuneConstraintType, IndexTuningPreset, OptimizeDirection,
-    Parameter as TuneParameter, ParameterSpace, ParameterType as TuneParameterType,
-    ParameterValue, SearchStrategy, Trial, TrialState, TuneMetric, TuneResult,
-    TunerStatsSummary, WorkloadAnalyzer as TuneWorkloadAnalyzer, WorkloadConfig as TuneWorkloadConfig,
-    WorkloadRecommendation as TuneWorkloadRecommendation,
-    hnsw_parameter_space, ivf_parameter_space,
+    Parameter as TuneParameter, ParameterSpace, ParameterType as TuneParameterType, ParameterValue,
+    SearchStrategy, Trial, TrialState, TuneMetric, TuneResult, TunerStatsSummary,
+    WorkloadAnalyzer as TuneWorkloadAnalyzer, WorkloadConfig as TuneWorkloadConfig,
+    WorkloadRecommendation as TuneWorkloadRecommendation, hnsw_parameter_space,
+    ivf_parameter_space,
 };
-pub use anomaly_detection::{
-    AnomalyConfig, AnomalyDetector as VectorAnomalyDetector,
-    AnomalyDetectorBuilder as VectorAnomalyDetectorBuilder, AnomalyRecord, AnomalyType,
-    BatchDetectionResult, DetectionMethod, DetectionResult, DetectionStats, DetectionSummary,
-    DriftConfig, DriftDetector, DriftEvent, DriftMethod, DriftSeverity,
+pub use cost_optimizer::{
+    AutoScalerConfig, BudgetStatus, CostAnalysis, CostAwareAutoScaler,
+    CostBreakdown as CostOptimizerBreakdown, CostForecast, CostOptimizer, CostOptimizerBuilder,
+    CostOptimizerConfig, CostPeriod, CostRecommendation, CostRecord, CostTrend, EffortLevel,
+    OptimizationAction, OptimizationCategory, OptimizerStatsSummary, RecommendationStatus,
+    ResourcePricing, ResourceUsage as CostResourceUsage, RiskLevel, ScaleAction, ScalingDecision,
+    TrendDirection as CostTrendDirection,
+};
+pub use neural_ranker::{
+    ActivationFn, CombinationMethod, CrossEncoder, CrossEncoderConfig, EnsembleConfig,
+    EnsembleRanker, LateInteractionConfig, LateInteractionModel, LearnedSparseConfig,
+    LearnedSparseModel, ModelType as NeuralModelType, NeuralRanker, NeuralRankerBuilder,
+    NeuralRankerConfig, Ranker as NeuralRankerTrait, RankerStatsSummary, RerankCandidate,
+    RerankResponse, RerankResult, SimilarityFn, SparseRepresentation,
 };
 pub use query_analytics::{
     AggregateStats as AnalyticsAggregateStats, Alert as AnalyticsAlert,
@@ -827,18 +834,10 @@ pub use query_analytics::{
     RecommendationCategory, ReportConfig, ReportFormat, TimeRange, TimeSeriesPoint, TrendData,
     TrendDirection as AnalyticsTrendDirection,
 };
-pub use cost_optimizer::{
-    AutoScalerConfig, BudgetStatus, CostAnalysis, CostAwareAutoScaler,
-    CostBreakdown as CostOptimizerBreakdown, CostForecast, CostOptimizer, CostOptimizerBuilder,
-    CostOptimizerConfig, CostPeriod, CostRecommendation, CostRecord, CostTrend, EffortLevel,
-    OptimizationAction, OptimizationCategory, OptimizerStatsSummary, RecommendationStatus,
-    ResourcePricing, ResourceUsage as CostResourceUsage, RiskLevel, ScaleAction, ScalingDecision,
-    TrendDirection as CostTrendDirection,
-};
 
 /// Initialize tracing subscriber for logging
 pub fn init_tracing() {
-    use tracing_subscriber::{fmt, EnvFilter};
+    use tracing_subscriber::{EnvFilter, fmt};
 
     let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
 
diff --git a/src/lineage.rs b/src/lineage.rs
index 74cb372..85cb551 100644
--- a/src/lineage.rs
+++ b/src/lineage.rs
@@ -35,10 +35,10 @@
 //! println!("Transformations: {:?}", lineage.transformations);
 //! ```
 
-use std::collections::HashMap;
-use std::sync::{Arc, RwLock};
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
 
 use crate::error::VecStoreError;
 
@@ -207,26 +207,18 @@ pub enum TransformationType {
         to_dims: usize,
     },
     /// Vector was quantized
-    Quantized {
-        bits: u8,
-    },
+    Quantized { bits: u8 },
     /// Product quantization was applied
     ProductQuantized {
         num_subvectors: usize,
         bits_per_subvector: u8,
     },
     /// Vector was averaged with others
-    Averaged {
-        source_count: usize,
-    },
+    Averaged { source_count: usize },
     /// Vector was concatenated with others
-    Concatenated {
-        source_ids: Vec<String>,
-    },
+    Concatenated { source_ids: Vec<String> },
     /// Vector was updated/modified
-    Updated {
-        reason: String,
-    },
+    Updated { reason: String },
     /// Custom transformation
     Custom {
         name: String,
@@ -433,7 +425,11 @@ impl LineageTracker {
     }
 
     /// Register a new vector with its origin
-    pub fn register(&self, vector_id: impl Into<String>, origin: VectorOrigin) -> Result<(), VecStoreError> {
+    pub fn register(
+        &self,
+        vector_id: impl Into<String>,
+        origin: VectorOrigin,
+    ) -> Result<(), VecStoreError> {
         let id = vector_id.into();
         let lineage = VectorLineage {
             vector_id: id.clone(),
@@ -447,9 +443,10 @@ impl LineageTracker {
             access_log: Vec::new(),
         };
 
-        let mut store = self.lineage.write().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire write lock".into())
-        })?;
+        let mut store = self
+            .lineage
+            .write()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire write lock".into()))?;
 
         store.insert(id, lineage);
         Ok(())
@@ -464,9 +461,10 @@ impl LineageTracker {
     ) -> Result<(), VecStoreError> {
         let id = vector_id.into();
 
-        let mut store = self.lineage.write().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire write lock".into())
-        })?;
+        let mut store = self
+            .lineage
+            .write()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire write lock".into()))?;
 
         // Update parent's child_ids
         for parent_id in &parent_ids {
@@ -509,9 +507,10 @@ impl LineageTracker {
         before_hash: Option<u64>,
         after_hash: Option<u64>,
     ) -> Result<(), VecStoreError> {
-        let mut store = self.lineage.write().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire write lock".into())
-        })?;
+        let mut store = self
+            .lineage
+            .write()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire write lock".into()))?;
 
         let lineage = store.get_mut(vector_id).ok_or_else(|| {
             VecStoreError::NotFound(format!("Vector {} not found in lineage", vector_id))
@@ -550,9 +549,10 @@ impl LineageTracker {
             return Ok(());
         }
 
-        let mut store = self.lineage.write().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire write lock".into())
-        })?;
+        let mut store = self
+            .lineage
+            .write()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire write lock".into()))?;
 
         if let Some(lineage) = store.get_mut(vector_id) {
             lineage.access_log.push(AccessRecord {
@@ -568,9 +568,10 @@ impl LineageTracker {
 
     /// Get lineage for a vector
     pub fn get_lineage(&self, vector_id: &str) -> Result<VectorLineage, VecStoreError> {
-        let store = self.lineage.read().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire read lock".into())
-        })?;
+        let store = self
+            .lineage
+            .read()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire read lock".into()))?;
 
         store.get(vector_id).cloned().ok_or_else(|| {
             VecStoreError::NotFound(format!("Vector {} not found in lineage", vector_id))
@@ -579,9 +580,10 @@ impl LineageTracker {
 
     /// Get full lineage tree (including ancestors)
     pub fn get_lineage_tree(&self, vector_id: &str) -> Result<Vec<VectorLineage>, VecStoreError> {
-        let store = self.lineage.read().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire read lock".into())
-        })?;
+        let store = self
+            .lineage
+            .read()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire read lock".into()))?;
 
         let mut result = Vec::new();
         let mut to_visit = vec![vector_id.to_string()];
@@ -612,9 +614,10 @@ impl LineageTracker {
         vector_id: &str,
         tags: Vec<String>,
     ) -> Result<(), VecStoreError> {
-        let mut store = self.lineage.write().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire write lock".into())
-        })?;
+        let mut store = self
+            .lineage
+            .write()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire write lock".into()))?;
 
         let lineage = store.get_mut(vector_id).ok_or_else(|| {
             VecStoreError::NotFound(format!("Vector {} not found in lineage", vector_id))
@@ -634,9 +637,10 @@ impl LineageTracker {
 
     /// Check retention and get vectors that need action
     pub fn check_retention(&self) -> Result<Vec<RetentionRecord>, VecStoreError> {
-        let store = self.lineage.read().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire read lock".into())
-        })?;
+        let store = self
+            .lineage
+            .read()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire read lock".into()))?;
 
         let now = Utc::now();
         let mut records = Vec::new();
@@ -645,7 +649,10 @@ impl LineageTracker {
             for (policy_name, policy) in &self.retention_policies {
                 // Check if policy applies to this vector
                 let applies = policy.applies_to_tags.is_empty()
-                    || lineage.compliance_tags.iter().any(|t| policy.applies_to_tags.contains(t));
+                    || lineage
+                        .compliance_tags
+                        .iter()
+                        .any(|t| policy.applies_to_tags.contains(t));
 
                 if !applies {
                     continue;
@@ -681,9 +688,10 @@ impl LineageTracker {
         period_start: DateTime<Utc>,
         period_end: DateTime<Utc>,
     ) -> Result<ComplianceReport, VecStoreError> {
-        let store = self.lineage.read().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire read lock".into())
-        })?;
+        let store = self
+            .lineage
+            .read()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire read lock".into()))?;
 
         let mut by_source_type: HashMap<String, usize> = HashMap::new();
         let mut by_model: HashMap<String, usize> = HashMap::new();
@@ -734,7 +742,8 @@ impl LineageTracker {
         let mut issues = Vec::new();
 
         // Check for expired vectors
-        let expired: Vec<_> = retention_status.iter()
+        let expired: Vec<_> = retention_status
+            .iter()
             .filter(|r| r.is_expired)
             .map(|r| r.vector_id.clone())
             .collect();
@@ -743,14 +752,18 @@ impl LineageTracker {
             issues.push(ComplianceIssue {
                 severity: IssueSeverity::Warning,
                 category: "Retention".to_string(),
-                description: format!("{} vectors have exceeded their retention period", expired.len()),
+                description: format!(
+                    "{} vectors have exceeded their retention period",
+                    expired.len()
+                ),
                 affected_vectors: expired,
                 recommendation: "Review and apply retention policies".to_string(),
             });
         }
 
         // Check for vectors without model info
-        let missing_model: Vec<_> = store.iter()
+        let missing_model: Vec<_> = store
+            .iter()
             .filter(|(_, l)| l.origin.embedding_model.is_none())
             .map(|(id, _)| id.clone())
             .collect();
@@ -759,7 +772,10 @@ impl LineageTracker {
             issues.push(ComplianceIssue {
                 severity: IssueSeverity::Info,
                 category: "Provenance".to_string(),
-                description: format!("{} vectors are missing model attribution", missing_model.len()),
+                description: format!(
+                    "{} vectors are missing model attribution",
+                    missing_model.len()
+                ),
                 affected_vectors: missing_model,
                 recommendation: "Update vectors with embedding model information".to_string(),
             });
@@ -786,11 +802,13 @@ impl LineageTracker {
 
     /// Find vectors by source
     pub fn find_by_source(&self, source_id: &str) -> Result<Vec<String>, VecStoreError> {
-        let store = self.lineage.read().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire read lock".into())
-        })?;
+        let store = self
+            .lineage
+            .read()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire read lock".into()))?;
 
-        let results: Vec<String> = store.iter()
+        let results: Vec<String> = store
+            .iter()
             .filter(|(_, lineage)| lineage.origin.source_id == source_id)
             .map(|(id, _)| id.clone())
             .collect();
@@ -800,13 +818,18 @@ impl LineageTracker {
 
     /// Find vectors by model
     pub fn find_by_model(&self, model_name: &str) -> Result<Vec<String>, VecStoreError> {
-        let store = self.lineage.read().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire read lock".into())
-        })?;
+        let store = self
+            .lineage
+            .read()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire read lock".into()))?;
 
-        let results: Vec<String> = store.iter()
+        let results: Vec<String> = store
+            .iter()
             .filter(|(_, lineage)| {
-                lineage.origin.embedding_model.as_ref()
+                lineage
+                    .origin
+                    .embedding_model
+                    .as_ref()
                     .map(|m| m.name == model_name)
                     .unwrap_or(false)
             })
@@ -818,11 +841,13 @@ impl LineageTracker {
 
     /// Get vectors with specific compliance tag
     pub fn find_by_tag(&self, tag: &str) -> Result<Vec<String>, VecStoreError> {
-        let store = self.lineage.read().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire read lock".into())
-        })?;
+        let store = self
+            .lineage
+            .read()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire read lock".into()))?;
 
-        let results: Vec<String> = store.iter()
+        let results: Vec<String> = store
+            .iter()
             .filter(|(_, lineage)| lineage.compliance_tags.contains(&tag.to_string()))
             .map(|(id, _)| id.clone())
             .collect();
@@ -833,22 +858,21 @@ impl LineageTracker {
     /// Export lineage data for a vector
     pub fn export_lineage(&self, vector_id: &str) -> Result<String, VecStoreError> {
         let lineage = self.get_lineage(vector_id)?;
-        serde_json::to_string_pretty(&lineage).map_err(|e| {
-            VecStoreError::Serialization(e.to_string())
-        })
+        serde_json::to_string_pretty(&lineage)
+            .map_err(|e| VecStoreError::Serialization(e.to_string()))
     }
 
     /// Import lineage data
     pub fn import_lineage(&self, json: &str) -> Result<String, VecStoreError> {
-        let lineage: VectorLineage = serde_json::from_str(json).map_err(|e| {
-            VecStoreError::Serialization(e.to_string())
-        })?;
+        let lineage: VectorLineage =
+            serde_json::from_str(json).map_err(|e| VecStoreError::Serialization(e.to_string()))?;
 
         let id = lineage.vector_id.clone();
 
-        let mut store = self.lineage.write().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire write lock".into())
-        })?;
+        let mut store = self
+            .lineage
+            .write()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire write lock".into()))?;
 
         store.insert(id.clone(), lineage);
         Ok(id)
@@ -856,9 +880,10 @@ impl LineageTracker {
 
     /// Delete lineage for a vector
     pub fn delete(&self, vector_id: &str) -> Result<(), VecStoreError> {
-        let mut store = self.lineage.write().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire write lock".into())
-        })?;
+        let mut store = self
+            .lineage
+            .write()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire write lock".into()))?;
 
         store.remove(vector_id);
         Ok(())
@@ -866,9 +891,10 @@ impl LineageTracker {
 
     /// Get total count of tracked vectors
     pub fn count(&self) -> Result<usize, VecStoreError> {
-        let store = self.lineage.read().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire read lock".into())
-        })?;
+        let store = self
+            .lineage
+            .read()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire read lock".into()))?;
 
         Ok(store.len())
     }
@@ -903,8 +929,7 @@ mod tests {
     fn test_register_and_get_lineage() {
         let tracker = LineageTracker::new();
 
-        let origin = VectorOrigin::new("doc1")
-            .from_model("test-model");
+        let origin = VectorOrigin::new("doc1").from_model("test-model");
 
         tracker.register("vec1", origin).unwrap();
 
@@ -921,8 +946,12 @@ mod tests {
         let origin = VectorOrigin::new("doc1");
         tracker.register("vec1", origin).unwrap();
 
-        tracker.add_transformation("vec1", TransformationType::Normalized).unwrap();
-        tracker.add_transformation("vec1", TransformationType::Quantized { bits: 8 }).unwrap();
+        tracker
+            .add_transformation("vec1", TransformationType::Normalized)
+            .unwrap();
+        tracker
+            .add_transformation("vec1", TransformationType::Quantized { bits: 8 })
+            .unwrap();
 
         let lineage = tracker.get_lineage("vec1").unwrap();
         assert_eq!(lineage.transformations.len(), 2);
@@ -934,16 +963,22 @@ mod tests {
         let tracker = LineageTracker::new();
 
         // Register parent vectors
-        tracker.register("parent1", VectorOrigin::new("doc1")).unwrap();
-        tracker.register("parent2", VectorOrigin::new("doc2")).unwrap();
+        tracker
+            .register("parent1", VectorOrigin::new("doc1"))
+            .unwrap();
+        tracker
+            .register("parent2", VectorOrigin::new("doc2"))
+            .unwrap();
 
         // Register derived vector
         let origin = VectorOrigin::new("derived_source");
-        tracker.register_derived(
-            "child1",
-            origin,
-            vec!["parent1".to_string(), "parent2".to_string()],
-        ).unwrap();
+        tracker
+            .register_derived(
+                "child1",
+                origin,
+                vec!["parent1".to_string(), "parent2".to_string()],
+            )
+            .unwrap();
 
         // Check child
         let child_lineage = tracker.get_lineage("child1").unwrap();
@@ -961,12 +996,14 @@ mod tests {
         let origin = VectorOrigin::new("doc1");
         tracker.register("vec1", origin).unwrap();
 
-        tracker.log_access(
-            "vec1",
-            AccessType::SearchResult,
-            Some("user123".to_string()),
-            Some("query456".to_string()),
-        ).unwrap();
+        tracker
+            .log_access(
+                "vec1",
+                AccessType::SearchResult,
+                Some("user123".to_string()),
+                Some("query456".to_string()),
+            )
+            .unwrap();
 
         let lineage = tracker.get_lineage("vec1").unwrap();
         assert_eq!(lineage.access_log.len(), 1);
@@ -980,10 +1017,9 @@ mod tests {
         let origin = VectorOrigin::new("doc1");
         tracker.register("vec1", origin).unwrap();
 
-        tracker.add_compliance_tags("vec1", vec![
-            "GDPR".to_string(),
-            "PII".to_string(),
-        ]).unwrap();
+        tracker
+            .add_compliance_tags("vec1", vec!["GDPR".to_string(), "PII".to_string()])
+            .unwrap();
 
         let lineage = tracker.get_lineage("vec1").unwrap();
         assert!(lineage.compliance_tags.contains(&"GDPR".to_string()));
@@ -1006,9 +1042,15 @@ mod tests {
     fn test_find_by_model() {
         let tracker = LineageTracker::new();
 
-        tracker.register("vec1", VectorOrigin::new("doc1").from_model("model-a")).unwrap();
-        tracker.register("vec2", VectorOrigin::new("doc2").from_model("model-a")).unwrap();
-        tracker.register("vec3", VectorOrigin::new("doc3").from_model("model-b")).unwrap();
+        tracker
+            .register("vec1", VectorOrigin::new("doc1").from_model("model-a"))
+            .unwrap();
+        tracker
+            .register("vec2", VectorOrigin::new("doc2").from_model("model-a"))
+            .unwrap();
+        tracker
+            .register("vec3", VectorOrigin::new("doc3").from_model("model-b"))
+            .unwrap();
 
         let results = tracker.find_by_model("model-a").unwrap();
         assert_eq!(results.len(), 2);
@@ -1019,9 +1061,23 @@ mod tests {
         let tracker = LineageTracker::new();
 
         // Build a tree: grandparent -> parent -> child
-        tracker.register("gp", VectorOrigin::new("gp_source")).unwrap();
-        tracker.register_derived("parent", VectorOrigin::new("parent_source"), vec!["gp".to_string()]).unwrap();
-        tracker.register_derived("child", VectorOrigin::new("child_source"), vec!["parent".to_string()]).unwrap();
+        tracker
+            .register("gp", VectorOrigin::new("gp_source"))
+            .unwrap();
+        tracker
+            .register_derived(
+                "parent",
+                VectorOrigin::new("parent_source"),
+                vec!["gp".to_string()],
+            )
+            .unwrap();
+        tracker
+            .register_derived(
+                "child",
+                VectorOrigin::new("child_source"),
+                vec!["parent".to_string()],
+            )
+            .unwrap();
 
         let tree = tracker.get_lineage_tree("child").unwrap();
         assert_eq!(tree.len(), 3);
@@ -1035,7 +1091,9 @@ mod tests {
             .from_model("test-model")
             .with_type(SourceType::Document);
         tracker.register("vec1", origin).unwrap();
-        tracker.add_transformation("vec1", TransformationType::Normalized).unwrap();
+        tracker
+            .add_transformation("vec1", TransformationType::Normalized)
+            .unwrap();
 
         // Export
         let json = tracker.export_lineage("vec1").unwrap();
@@ -1054,12 +1112,25 @@ mod tests {
     fn test_compliance_report() {
         let tracker = LineageTracker::new();
 
-        tracker.register("vec1", VectorOrigin::new("doc1").from_model("model-a")).unwrap();
-        tracker.register("vec2", VectorOrigin::new("doc2").from_model("model-b")).unwrap();
+        tracker
+            .register("vec1", VectorOrigin::new("doc1").from_model("model-a"))
+            .unwrap();
+        tracker
+            .register("vec2", VectorOrigin::new("doc2").from_model("model-b"))
+            .unwrap();
         tracker.register("vec3", VectorOrigin::new("doc3")).unwrap(); // No model
 
-        tracker.log_access("vec1", AccessType::Read, Some("user1".to_string()), None).unwrap();
-        tracker.log_access("vec1", AccessType::SearchResult, Some("user2".to_string()), None).unwrap();
+        tracker
+            .log_access("vec1", AccessType::Read, Some("user1".to_string()), None)
+            .unwrap();
+        tracker
+            .log_access(
+                "vec1",
+                AccessType::SearchResult,
+                Some("user2".to_string()),
+                None,
+            )
+            .unwrap();
 
         let start = Utc::now() - chrono::Duration::hours(1);
         let end = Utc::now() + chrono::Duration::hours(1);
diff --git a/src/llm_cache.rs b/src/llm_cache.rs
index a52dd09..6c091cd 100644
--- a/src/llm_cache.rs
+++ b/src/llm_cache.rs
@@ -37,9 +37,9 @@
 //! assert_eq!(response1, response2); // Same response from cache
 //! ```
 
+use serde::{Deserialize, Serialize};
 use std::sync::{Arc, RwLock};
 use std::time::{Duration, Instant};
-use serde::{Deserialize, Serialize};
 
 use crate::error::{Result, VecStoreError};
 
@@ -72,11 +72,17 @@ pub const DEFAULT_SIMILARITY_THRESHOLD: f32 = 0.95;
 pub const DEFAULT_MAX_SIZE: usize = 10000;
 
 #[inline]
-const fn default_similarity_threshold() -> f32 { DEFAULT_SIMILARITY_THRESHOLD }
+const fn default_similarity_threshold() -> f32 {
+    DEFAULT_SIMILARITY_THRESHOLD
+}
 #[inline]
-const fn default_max_size() -> usize { DEFAULT_MAX_SIZE }
+const fn default_max_size() -> usize {
+    DEFAULT_MAX_SIZE
+}
 #[inline]
-const fn default_true() -> bool { true }
+const fn default_true() -> bool {
+    true
+}
 
 impl Default for CacheConfig {
     fn default() -> Self {
@@ -255,7 +261,9 @@ impl SemanticCache {
 
     /// Find a similar cached query
     fn find_similar(&self, _query: &str, embedding: &[f32]) -> Result<Option<CacheHit>> {
-        let entries = self.entries.read()
+        let entries = self
+            .entries
+            .read()
             .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?;
         let ttl = Duration::from_secs(self.config.ttl_seconds);
 
@@ -271,9 +279,10 @@ impl SemanticCache {
             let similarity = Self::cosine_similarity(embedding, &entry.embedding);
 
             if similarity >= self.config.similarity_threshold
-                && (best_match.is_none() || similarity > best_match.unwrap().1) {
-                    best_match = Some((i, similarity));
-                }
+                && (best_match.is_none() || similarity > best_match.unwrap().1)
+            {
+                best_match = Some((i, similarity));
+            }
         }
 
         if let Some((idx, similarity)) = best_match {
@@ -296,13 +305,16 @@ impl SemanticCache {
         response: &str,
         metadata: Option<serde_json::Value>,
     ) -> Result<()> {
-        let mut entries = self.entries.write()
+        let mut entries = self
+            .entries
+            .write()
             .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?;
 
         // Evict if at capacity
         while entries.len() >= self.config.max_size {
             // Remove least recently accessed
-            if let Some(idx) = entries.iter()
+            if let Some(idx) = entries
+                .iter()
                 .enumerate()
                 .min_by_key(|(_, e)| e.last_accessed)
                 .map(|(i, _)| i)
@@ -330,7 +342,9 @@ impl SemanticCache {
             return Ok(());
         }
 
-        let mut analytics = self.analytics.write()
+        let mut analytics = self
+            .analytics
+            .write()
             .map_err(|_| VecStoreError::LockError("analytics lock poisoned".into()))?;
         analytics.total_queries += 1;
         analytics.cache_hits += 1;
@@ -345,8 +359,11 @@ impl SemanticCache {
         analytics.avg_hit_similarity =
             (analytics.avg_hit_similarity * (n - 1.0) + hit.similarity) / n;
 
-        analytics.cache_size = self.entries.read()
-            .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?.len();
+        analytics.cache_size = self
+            .entries
+            .read()
+            .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?
+            .len();
         Ok(())
     }
 
@@ -356,31 +373,43 @@ impl SemanticCache {
             return Ok(());
         }
 
-        let mut analytics = self.analytics.write()
+        let mut analytics = self
+            .analytics
+            .write()
             .map_err(|_| VecStoreError::LockError("analytics lock poisoned".into()))?;
         analytics.total_queries += 1;
         analytics.cache_misses += 1;
-        analytics.cache_size = self.entries.read()
-            .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?.len();
+        analytics.cache_size = self
+            .entries
+            .read()
+            .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?
+            .len();
         Ok(())
     }
 
     /// Get cache analytics
     pub fn analytics(&self) -> Result<CacheAnalytics> {
-        Ok(self.analytics.read()
-            .map_err(|_| VecStoreError::LockError("analytics lock poisoned".into()))?.clone())
+        Ok(self
+            .analytics
+            .read()
+            .map_err(|_| VecStoreError::LockError("analytics lock poisoned".into()))?
+            .clone())
     }
 
     /// Clear the cache
     pub fn clear(&self) -> Result<()> {
-        self.entries.write()
-            .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?.clear();
+        self.entries
+            .write()
+            .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?
+            .clear();
         Ok(())
     }
 
     /// Invalidate expired entries
     pub fn cleanup(&self) -> Result<usize> {
-        let mut entries = self.entries.write()
+        let mut entries = self
+            .entries
+            .write()
             .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?;
         let ttl = Duration::from_secs(self.config.ttl_seconds);
 
@@ -404,14 +433,20 @@ impl SemanticCache {
 
     /// Get cache size
     pub fn len(&self) -> Result<usize> {
-        Ok(self.entries.read()
-            .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?.len())
+        Ok(self
+            .entries
+            .read()
+            .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?
+            .len())
     }
 
     /// Check if empty
     pub fn is_empty(&self) -> Result<bool> {
-        Ok(self.entries.read()
-            .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?.is_empty())
+        Ok(self
+            .entries
+            .read()
+            .map_err(|_| VecStoreError::LockError("entries lock poisoned".into()))?
+            .is_empty())
     }
 }
 
@@ -514,20 +549,20 @@ mod tests {
 
         // First query - miss
         let embedding1 = vec![0.1f32; 64];
-        let result1 = cache.get_or_generate(
-            "What is AI?",
-            &embedding1,
-            || Ok("AI is artificial intelligence.".to_string()),
-        ).unwrap();
+        let result1 = cache
+            .get_or_generate("What is AI?", &embedding1, || {
+                Ok("AI is artificial intelligence.".to_string())
+            })
+            .unwrap();
 
         assert!(!result1.cache_hit);
 
         // Same query - hit
-        let result2 = cache.get_or_generate(
-            "What is AI?",
-            &embedding1,
-            || Ok("Should not be called".to_string()),
-        ).unwrap();
+        let result2 = cache
+            .get_or_generate("What is AI?", &embedding1, || {
+                Ok("Should not be called".to_string())
+            })
+            .unwrap();
 
         assert!(result2.cache_hit);
         assert_eq!(result1.response, result2.response);
@@ -541,10 +576,14 @@ mod tests {
         let embedding = vec![0.1f32; 64];
 
         // Miss
-        cache.get_or_generate("Query 1", &embedding, || Ok("Response 1".to_string())).unwrap();
+        cache
+            .get_or_generate("Query 1", &embedding, || Ok("Response 1".to_string()))
+            .unwrap();
 
         // Hit
-        cache.get_or_generate("Query 1", &embedding, || Ok("Response 2".to_string())).unwrap();
+        cache
+            .get_or_generate("Query 1", &embedding, || Ok("Response 2".to_string()))
+            .unwrap();
 
         let analytics = cache.analytics().unwrap();
         assert_eq!(analytics.total_queries, 2);
diff --git a/src/lsh.rs b/src/lsh.rs
index dee69a9..e9f83c2 100644
--- a/src/lsh.rs
+++ b/src/lsh.rs
@@ -49,7 +49,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use rand::rngs::StdRng;
 use rand::{Rng, SeedableRng};
 use serde::{Deserialize, Serialize};
@@ -90,7 +90,9 @@ struct HashFunction {
 impl HashFunction {
     /// Create a new random hash function
     fn new(dimension: usize, rng: &mut StdRng) -> Self {
-        let projection: Vec<f32> = (0..dimension).map(|_| rng.random_range(-1.0..1.0)).collect();
+        let projection: Vec<f32> = (0..dimension)
+            .map(|_| rng.random_range(-1.0..1.0))
+            .collect();
 
         Self { projection }
     }
@@ -105,11 +107,7 @@ impl HashFunction {
             .map(|(a, b)| a * b)
             .sum();
 
-        if dot_product >= 0.0 {
-            1
-        } else {
-            0
-        }
+        if dot_product >= 0.0 { 1 } else { 0 }
     }
 }
 
@@ -163,9 +161,7 @@ impl HashTable {
     fn get_candidates(&self, query: &[f32]) -> Vec<(String, Vec<f32>)> {
         let hash_code = self.compute_hash(query);
 
-        self.buckets
-            .get(&hash_code).cloned()
-            .unwrap_or_default()
+        self.buckets.get(&hash_code).cloned().unwrap_or_default()
     }
 
     /// Remove a vector by ID
diff --git a/src/managed_embeddings.rs b/src/managed_embeddings.rs
index 0696ab1..35dda6f 100644
--- a/src/managed_embeddings.rs
+++ b/src/managed_embeddings.rs
@@ -401,16 +401,20 @@ impl EmbeddingCache {
             self.evict_oldest();
         }
 
-        self.entries.insert(key, CacheEntry {
-            embedding,
-            model: model.to_string(),
-            cached_at: Instant::now(),
-            hits: 0,
-        });
+        self.entries.insert(
+            key,
+            CacheEntry {
+                embedding,
+                model: model.to_string(),
+                cached_at: Instant::now(),
+                hits: 0,
+            },
+        );
     }
 
     fn evict_oldest(&mut self) {
-        let oldest = self.entries
+        let oldest = self
+            .entries
             .iter()
             .min_by_key(|(_, e)| e.cached_at)
             .map(|(k, _)| k.clone());
@@ -508,29 +512,43 @@ impl UsageTracker {
         }
     }
 
-    fn record(&mut self, provider: &str, model: &str, tokens: usize, embeddings: usize, cost: f64, latency_ms: u64) {
+    fn record(
+        &mut self,
+        provider: &str,
+        model: &str,
+        tokens: usize,
+        embeddings: usize,
+        cost: f64,
+        latency_ms: u64,
+    ) {
         self.total_tokens += tokens as u64;
         self.total_requests += 1;
         self.total_embeddings += embeddings as u64;
         self.total_latency_ms += latency_ms;
 
         // By provider
-        let provider_usage = self.by_provider.entry(provider.to_string()).or_insert(ProviderUsage {
-            tokens: 0,
-            requests: 0,
-            errors: 0,
-            cost: 0.0,
-        });
+        let provider_usage =
+            self.by_provider
+                .entry(provider.to_string())
+                .or_insert(ProviderUsage {
+                    tokens: 0,
+                    requests: 0,
+                    errors: 0,
+                    cost: 0.0,
+                });
         provider_usage.tokens += tokens as u64;
         provider_usage.requests += 1;
         provider_usage.cost += cost;
 
         // By model
-        let model_usage = self.by_model.entry(model.to_string()).or_insert(ModelUsage {
-            tokens: 0,
-            embeddings: 0,
-            cost: 0.0,
-        });
+        let model_usage = self
+            .by_model
+            .entry(model.to_string())
+            .or_insert(ModelUsage {
+                tokens: 0,
+                embeddings: 0,
+                cost: 0.0,
+            });
         model_usage.tokens += tokens as u64;
         model_usage.embeddings += embeddings as u64;
         model_usage.cost += cost;
@@ -545,12 +563,15 @@ impl UsageTracker {
     }
 
     fn record_error(&mut self, provider: &str) {
-        let provider_usage = self.by_provider.entry(provider.to_string()).or_insert(ProviderUsage {
-            tokens: 0,
-            requests: 0,
-            errors: 0,
-            cost: 0.0,
-        });
+        let provider_usage =
+            self.by_provider
+                .entry(provider.to_string())
+                .or_insert(ProviderUsage {
+                    tokens: 0,
+                    requests: 0,
+                    errors: 0,
+                    cost: 0.0,
+                });
         provider_usage.errors += 1;
     }
 
@@ -608,7 +629,10 @@ impl EmbeddingService {
     /// Embed texts
     pub fn embed(&self, request: EmbeddingRequest) -> Result<EmbeddingResponse> {
         let start = Instant::now();
-        let model = request.model_override.as_ref().unwrap_or(&self.config.primary_model);
+        let model = request
+            .model_override
+            .as_ref()
+            .unwrap_or(&self.config.primary_model);
 
         let mut embeddings = Vec::with_capacity(request.texts.len());
         let mut cache_hits = 0;
@@ -616,7 +640,9 @@ impl EmbeddingService {
 
         // Check cache for each text
         if self.config.enable_cache && !request.skip_cache {
-            let mut cache = self.cache.write()
+            let mut cache = self
+                .cache
+                .write()
                 .map_err(|_| VecStoreError::LockError("cache lock poisoned".into()))?;
 
             for (i, text) in request.texts.iter().enumerate() {
@@ -625,18 +651,25 @@ impl EmbeddingService {
                 if let Some(cached) = cache.get(&cache_key) {
                     embeddings.push((i, cached));
                     cache_hits += 1;
-                    self.usage.write()
+                    self.usage
+                        .write()
                         .map_err(|_| VecStoreError::LockError("usage lock poisoned".into()))?
                         .record_cache_hit();
                 } else {
                     texts_to_embed.push((i, text.clone()));
-                    self.usage.write()
+                    self.usage
+                        .write()
                         .map_err(|_| VecStoreError::LockError("usage lock poisoned".into()))?
                         .record_cache_miss();
                 }
             }
         } else {
-            texts_to_embed = request.texts.iter().enumerate().map(|(i, t)| (i, t.clone())).collect();
+            texts_to_embed = request
+                .texts
+                .iter()
+                .enumerate()
+                .map(|(i, t)| (i, t.clone()))
+                .collect();
         }
 
         // Embed remaining texts
@@ -644,7 +677,9 @@ impl EmbeddingService {
         if !texts_to_embed.is_empty() {
             // Rate limiting
             {
-                let mut limiter = self.rate_limiter.write()
+                let mut limiter = self
+                    .rate_limiter
+                    .write()
                     .map_err(|_| VecStoreError::LockError("rate_limiter lock poisoned".into()))?;
                 if !limiter.acquire(1.0) {
                     // Would need to wait in real async implementation
@@ -653,12 +688,15 @@ impl EmbeddingService {
 
             // Call embedding provider
             let texts: Vec<&str> = texts_to_embed.iter().map(|(_, t)| t.as_str()).collect();
-            let (new_embeddings, tokens) = self.call_provider(&texts, model, request.task_type.as_ref())?;
+            let (new_embeddings, tokens) =
+                self.call_provider(&texts, model, request.task_type.as_ref())?;
             total_tokens = tokens;
 
             // Store in cache
             if self.config.enable_cache && !request.skip_cache {
-                let mut cache = self.cache.write()
+                let mut cache = self
+                    .cache
+                    .write()
                     .map_err(|_| VecStoreError::LockError("cache lock poisoned".into()))?;
                 for ((i, text), emb) in texts_to_embed.iter().zip(&new_embeddings) {
                     let cache_key = self.cache_key(text, &model.model, request.task_type.as_ref());
@@ -678,13 +716,10 @@ impl EmbeddingService {
 
         // Apply dimension override if specified
         let final_embeddings = if let Some(dim) = request.dimension_override {
-            final_embeddings.into_iter().map(|e| {
-                if e.len() > dim {
-                    e[..dim].to_vec()
-                } else {
-                    e
-                }
-            }).collect()
+            final_embeddings
+                .into_iter()
+                .map(|e| if e.len() > dim { e[..dim].to_vec() } else { e })
+                .collect()
         } else {
             final_embeddings
         };
@@ -695,7 +730,8 @@ impl EmbeddingService {
         // Record usage
         if self.config.track_usage && total_tokens > 0 {
             let provider_name = format!("{:?}", model.provider);
-            self.usage.write()
+            self.usage
+                .write()
                 .map_err(|_| VecStoreError::LockError("usage lock poisoned".into()))?
                 .record(
                     &provider_name,
@@ -721,39 +757,45 @@ impl EmbeddingService {
     pub fn embed_one(&self, text: &str) -> Result<Vec<f32>> {
         let request = EmbeddingRequest::new(vec![text.to_string()]);
         let response = self.embed(request)?;
-        response.embeddings.into_iter().next().ok_or_else(|| {
-            VecStoreError::EmbeddingError("No embedding returned".to_string())
-        })
+        response
+            .embeddings
+            .into_iter()
+            .next()
+            .ok_or_else(|| VecStoreError::EmbeddingError("No embedding returned".to_string()))
     }
 
     /// Embed for query (uses query task type)
     pub fn embed_query(&self, text: &str) -> Result<Vec<f32>> {
-        let request = EmbeddingRequest::new(vec![text.to_string()])
-            .with_task_type(TaskType::Query);
+        let request = EmbeddingRequest::new(vec![text.to_string()]).with_task_type(TaskType::Query);
         let response = self.embed(request)?;
-        response.embeddings.into_iter().next().ok_or_else(|| {
-            VecStoreError::EmbeddingError("No embedding returned".to_string())
-        })
+        response
+            .embeddings
+            .into_iter()
+            .next()
+            .ok_or_else(|| VecStoreError::EmbeddingError("No embedding returned".to_string()))
     }
 
     /// Embed for documents (uses document task type)
     pub fn embed_documents(&self, texts: Vec<String>) -> Result<Vec<Vec<f32>>> {
-        let request = EmbeddingRequest::new(texts)
-            .with_task_type(TaskType::Document);
+        let request = EmbeddingRequest::new(texts).with_task_type(TaskType::Document);
         let response = self.embed(request)?;
         Ok(response.embeddings)
     }
 
     /// Get usage statistics
     pub fn usage(&self) -> Result<UsageStats> {
-        let usage = self.usage.read()
+        let usage = self
+            .usage
+            .read()
             .map_err(|_| VecStoreError::LockError("usage lock poisoned".into()))?;
         Ok(usage.stats())
     }
 
     /// Reset usage tracking
     pub fn reset_usage(&self) -> Result<()> {
-        let mut usage = self.usage.write()
+        let mut usage = self
+            .usage
+            .write()
             .map_err(|_| VecStoreError::LockError("usage lock poisoned".into()))?;
         *usage = UsageTracker::new();
         Ok(())
@@ -771,7 +813,9 @@ impl EmbeddingService {
 
     /// Clear embedding cache
     pub fn clear_cache(&self) -> Result<()> {
-        let mut cache = self.cache.write()
+        let mut cache = self
+            .cache
+            .write()
             .map_err(|_| VecStoreError::LockError("cache lock poisoned".into()))?;
         *cache = EmbeddingCache::new(self.config.max_cache_entries, self.config.cache_ttl_seconds);
         Ok(())
@@ -779,7 +823,9 @@ impl EmbeddingService {
 
     /// Get cache statistics
     pub fn cache_stats(&self) -> Result<(usize, u64)> {
-        let cache = self.cache.read()
+        let cache = self
+            .cache
+            .read()
             .map_err(|_| VecStoreError::LockError("cache lock poisoned".into()))?;
         let stats = cache.stats();
         Ok((stats.entries, stats.total_hits))
@@ -800,7 +846,12 @@ impl EmbeddingService {
         format!("{:x}", hasher.finish())
     }
 
-    fn call_provider(&self, texts: &[&str], model: &ModelConfig, task_type: Option<&TaskType>) -> Result<(Vec<Vec<f32>>, usize)> {
+    fn call_provider(
+        &self,
+        texts: &[&str],
+        model: &ModelConfig,
+        task_type: Option<&TaskType>,
+    ) -> Result<(Vec<Vec<f32>>, usize)> {
         // Simulated embedding - in production would call actual APIs
         match &model.provider {
             EmbeddingProvider::OpenAI => self.embed_openai(texts, model),
@@ -819,19 +870,34 @@ impl EmbeddingService {
         Ok((embeddings, total_tokens))
     }
 
-    fn embed_cohere(&self, texts: &[&str], model: &ModelConfig, _task_type: Option<&TaskType>) -> Result<(Vec<Vec<f32>>, usize)> {
+    fn embed_cohere(
+        &self,
+        texts: &[&str],
+        model: &ModelConfig,
+        _task_type: Option<&TaskType>,
+    ) -> Result<(Vec<Vec<f32>>, usize)> {
         let total_tokens: usize = texts.iter().map(|t| t.split_whitespace().count()).sum();
         let embeddings = self.generate_embeddings(texts, model.dimension);
         Ok((embeddings, total_tokens))
     }
 
-    fn embed_voyage(&self, texts: &[&str], model: &ModelConfig, _task_type: Option<&TaskType>) -> Result<(Vec<Vec<f32>>, usize)> {
+    fn embed_voyage(
+        &self,
+        texts: &[&str],
+        model: &ModelConfig,
+        _task_type: Option<&TaskType>,
+    ) -> Result<(Vec<Vec<f32>>, usize)> {
         let total_tokens: usize = texts.iter().map(|t| t.split_whitespace().count()).sum();
         let embeddings = self.generate_embeddings(texts, model.dimension);
         Ok((embeddings, total_tokens))
     }
 
-    fn embed_jina(&self, texts: &[&str], model: &ModelConfig, _task_type: Option<&TaskType>) -> Result<(Vec<Vec<f32>>, usize)> {
+    fn embed_jina(
+        &self,
+        texts: &[&str],
+        model: &ModelConfig,
+        _task_type: Option<&TaskType>,
+    ) -> Result<(Vec<Vec<f32>>, usize)> {
         let total_tokens: usize = texts.iter().map(|t| t.split_whitespace().count()).sum();
         let embeddings = self.generate_embeddings(texts, model.dimension);
         Ok((embeddings, total_tokens))
@@ -847,8 +913,14 @@ impl EmbeddingService {
     ///
     /// Generates deterministic hash-based embeddings for testing and development.
     /// Production deployments should use supported providers (OpenAI, Cohere, Voyage, Jina, LocalONNX).
-    fn embed_simulated(&self, texts: &[&str], model: &ModelConfig) -> Result<(Vec<Vec<f32>>, usize)> {
-        tracing::warn!("Using simulated embeddings for unsupported provider - not suitable for production");
+    fn embed_simulated(
+        &self,
+        texts: &[&str],
+        model: &ModelConfig,
+    ) -> Result<(Vec<Vec<f32>>, usize)> {
+        tracing::warn!(
+            "Using simulated embeddings for unsupported provider - not suitable for production"
+        );
         let total_tokens: usize = texts.iter().map(|t| t.split_whitespace().count()).sum();
         let embeddings = self.generate_embeddings(texts, model.dimension);
         Ok((embeddings, total_tokens))
@@ -856,26 +928,31 @@ impl EmbeddingService {
 
     fn generate_embeddings(&self, texts: &[&str], dimension: usize) -> Vec<Vec<f32>> {
         // Generate deterministic embeddings based on text hash for testing/fallback
-        texts.iter().map(|text| {
-            let mut embedding = vec![0.0f32; dimension];
-            let bytes = text.as_bytes();
-
-            for (i, chunk) in bytes.chunks(4).enumerate() {
-                let idx = i % dimension;
-                let val: u32 = chunk.iter().fold(0u32, |acc, &b| acc.wrapping_add(b as u32));
-                embedding[idx] = ((val as f32) / 255.0 - 0.5) * 2.0;
-            }
+        texts
+            .iter()
+            .map(|text| {
+                let mut embedding = vec![0.0f32; dimension];
+                let bytes = text.as_bytes();
+
+                for (i, chunk) in bytes.chunks(4).enumerate() {
+                    let idx = i % dimension;
+                    let val: u32 = chunk
+                        .iter()
+                        .fold(0u32, |acc, &b| acc.wrapping_add(b as u32));
+                    embedding[idx] = ((val as f32) / 255.0 - 0.5) * 2.0;
+                }
 
-            // Normalize
-            let norm: f32 = embedding.iter().map(|x| x * x).sum::<f32>().sqrt();
-            if norm > 0.0 {
-                for x in &mut embedding {
-                    *x /= norm;
+                // Normalize
+                let norm: f32 = embedding.iter().map(|x| x * x).sum::<f32>().sqrt();
+                if norm > 0.0 {
+                    for x in &mut embedding {
+                        *x /= norm;
+                    }
                 }
-            }
 
-            embedding
-        }).collect()
+                embedding
+            })
+            .collect()
     }
 }
 
@@ -897,14 +974,23 @@ impl EmbeddingCollection {
     }
 
     /// Add document with automatic embedding
-    pub fn add(&self, id: &str, text: &str, metadata: HashMap<String, serde_json::Value>) -> Result<()> {
+    pub fn add(
+        &self,
+        id: &str,
+        text: &str,
+        metadata: HashMap<String, serde_json::Value>,
+    ) -> Result<()> {
         let embedding = self.service.embed_one(text)?;
 
-        let mut vectors = self.vectors.write()
+        let mut vectors = self
+            .vectors
+            .write()
             .map_err(|_| VecStoreError::LockError("vectors lock poisoned".into()))?;
         vectors.insert(id.to_string(), (embedding, metadata));
 
-        let mut texts = self.texts.write()
+        let mut texts = self
+            .texts
+            .write()
             .map_err(|_| VecStoreError::LockError("texts lock poisoned".into()))?;
         texts.insert(id.to_string(), text.to_string());
 
@@ -912,13 +998,20 @@ impl EmbeddingCollection {
     }
 
     /// Add multiple documents
-    pub fn add_batch(&self, documents: Vec<(String, String, HashMap<String, serde_json::Value>)>) -> Result<usize> {
+    pub fn add_batch(
+        &self,
+        documents: Vec<(String, String, HashMap<String, serde_json::Value>)>,
+    ) -> Result<usize> {
         let texts: Vec<String> = documents.iter().map(|(_, t, _)| t.clone()).collect();
         let embeddings = self.service.embed_documents(texts.clone())?;
 
-        let mut vectors = self.vectors.write()
+        let mut vectors = self
+            .vectors
+            .write()
             .map_err(|_| VecStoreError::LockError("vectors lock poisoned".into()))?;
-        let mut text_store = self.texts.write()
+        let mut text_store = self
+            .texts
+            .write()
             .map_err(|_| VecStoreError::LockError("texts lock poisoned".into()))?;
 
         for ((id, text, metadata), embedding) in documents.into_iter().zip(embeddings) {
@@ -933,9 +1026,13 @@ impl EmbeddingCollection {
     pub fn query(&self, text: &str, top_k: usize) -> Result<Vec<QueryResult>> {
         let query_embedding = self.service.embed_query(text)?;
 
-        let vectors = self.vectors.read()
+        let vectors = self
+            .vectors
+            .read()
             .map_err(|_| VecStoreError::LockError("vectors lock poisoned".into()))?;
-        let texts = self.texts.read()
+        let texts = self
+            .texts
+            .read()
             .map_err(|_| VecStoreError::LockError("texts lock poisoned".into()))?;
 
         let mut results: Vec<QueryResult> = vectors
@@ -959,16 +1056,22 @@ impl EmbeddingCollection {
 
     /// Get vector by ID
     pub fn get(&self, id: &str) -> Result<Option<Vec<f32>>> {
-        let vectors = self.vectors.read()
+        let vectors = self
+            .vectors
+            .read()
             .map_err(|_| VecStoreError::LockError("vectors lock poisoned".into()))?;
         Ok(vectors.get(id).map(|(v, _)| v.clone()))
     }
 
     /// Delete by ID
     pub fn delete(&self, id: &str) -> Result<bool> {
-        let mut vectors = self.vectors.write()
+        let mut vectors = self
+            .vectors
+            .write()
             .map_err(|_| VecStoreError::LockError("vectors lock poisoned".into()))?;
-        let mut texts = self.texts.write()
+        let mut texts = self
+            .texts
+            .write()
             .map_err(|_| VecStoreError::LockError("texts lock poisoned".into()))?;
         texts.remove(id);
         Ok(vectors.remove(id).is_some())
@@ -976,7 +1079,9 @@ impl EmbeddingCollection {
 
     /// Count documents
     pub fn count(&self) -> Result<usize> {
-        let vectors = self.vectors.read()
+        let vectors = self
+            .vectors
+            .read()
             .map_err(|_| VecStoreError::LockError("vectors lock poisoned".into()))?;
         Ok(vectors.len())
     }
@@ -1020,10 +1125,12 @@ mod tests {
         let config = EmbeddingServiceConfig::default();
         let service = EmbeddingService::new(config);
 
-        let response = service.embed(EmbeddingRequest::new(vec![
-            "Hello world".to_string(),
-            "Machine learning".to_string(),
-        ])).unwrap();
+        let response = service
+            .embed(EmbeddingRequest::new(vec![
+                "Hello world".to_string(),
+                "Machine learning".to_string(),
+            ]))
+            .unwrap();
 
         assert_eq!(response.embeddings.len(), 2);
         assert_eq!(response.embeddings[0].len(), 1536); // OpenAI small dimension
@@ -1035,10 +1142,14 @@ mod tests {
         let service = EmbeddingService::new(config);
 
         // First request
-        let response1 = service.embed(EmbeddingRequest::new(vec!["Hello".to_string()])).unwrap();
+        let response1 = service
+            .embed(EmbeddingRequest::new(vec!["Hello".to_string()]))
+            .unwrap();
 
         // Second request (should be cached)
-        let response2 = service.embed(EmbeddingRequest::new(vec!["Hello".to_string()])).unwrap();
+        let response2 = service
+            .embed(EmbeddingRequest::new(vec!["Hello".to_string()]))
+            .unwrap();
 
         assert_eq!(response2.cache_hits, 1);
         assert_eq!(response1.embeddings[0], response2.embeddings[0]);
@@ -1049,7 +1160,9 @@ mod tests {
         let config = EmbeddingServiceConfig::default();
         let service = EmbeddingService::new(config);
 
-        service.embed(EmbeddingRequest::new(vec!["Test".to_string()])).unwrap();
+        service
+            .embed(EmbeddingRequest::new(vec!["Test".to_string()]))
+            .unwrap();
 
         let usage = service.usage().unwrap();
         assert!(usage.total_requests > 0);
@@ -1061,8 +1174,12 @@ mod tests {
         let service = Arc::new(EmbeddingService::new(config));
         let collection = EmbeddingCollection::new(service);
 
-        collection.add("doc1", "Hello world", HashMap::new()).unwrap();
-        collection.add("doc2", "Machine learning tutorial", HashMap::new()).unwrap();
+        collection
+            .add("doc1", "Hello world", HashMap::new())
+            .unwrap();
+        collection
+            .add("doc2", "Machine learning tutorial", HashMap::new())
+            .unwrap();
 
         let results = collection.query("Hello", 10).unwrap();
         assert!(!results.is_empty());
@@ -1089,15 +1206,19 @@ mod tests {
         };
         let service = EmbeddingService::new(config);
 
-        let doc_embedding = service.embed(
-            EmbeddingRequest::new(vec!["Document text".to_string()])
-                .with_task_type(TaskType::Document)
-        ).unwrap();
-
-        let query_embedding = service.embed(
-            EmbeddingRequest::new(vec!["Query text".to_string()])
-                .with_task_type(TaskType::Query)
-        ).unwrap();
+        let doc_embedding = service
+            .embed(
+                EmbeddingRequest::new(vec!["Document text".to_string()])
+                    .with_task_type(TaskType::Document),
+            )
+            .unwrap();
+
+        let query_embedding = service
+            .embed(
+                EmbeddingRequest::new(vec!["Query text".to_string()])
+                    .with_task_type(TaskType::Query),
+            )
+            .unwrap();
 
         assert_eq!(doc_embedding.embeddings[0].len(), 1024);
         assert_eq!(query_embedding.embeddings[0].len(), 1024);
diff --git a/src/matryoshka.rs b/src/matryoshka.rs
index e6d054d..359ba97 100644
--- a/src/matryoshka.rs
+++ b/src/matryoshka.rs
@@ -44,7 +44,7 @@
 //! let results = store.search(&query, 10)?;
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -174,10 +174,11 @@ impl MatryoshkaEmbedding {
 
         // Try to get from full embedding
         if let Some(ref full) = self.full
-            && dim <= full.len() {
-                // Would need to compute truncated - return None for now
-                return None;
-            }
+            && dim <= full.len()
+        {
+            // Would need to compute truncated - return None for now
+            return None;
+        }
 
         // Return closest smaller dimension
         self.truncated
@@ -314,9 +315,10 @@ impl MatryoshkaStore {
             // Re-score candidates at higher dimension
             for (id, score) in &mut candidates {
                 if let Some(emb) = self.embeddings.get(id)
-                    && let Some(v) = emb.at_dimension(dim) {
-                        *score = self.cosine_similarity(&refined_query, v);
-                    }
+                    && let Some(v) = emb.at_dimension(dim)
+                {
+                    *score = self.cosine_similarity(&refined_query, v);
+                }
             }
 
             // Re-sort after refinement
@@ -755,7 +757,8 @@ impl AdaptiveSearch {
     fn estimate_optimal_dimension(&self, query: &[f32]) -> usize {
         // Simple heuristic: use query variance to estimate complexity
         let mean: f32 = query.iter().sum::<f32>() / query.len() as f32;
-        let variance: f32 = query.iter().map(|x| (x - mean).powi(2)).sum::<f32>() / query.len() as f32;
+        let variance: f32 =
+            query.iter().map(|x| (x - mean).powi(2)).sum::<f32>() / query.len() as f32;
 
         // Higher variance queries need more dimensions
         if variance > 0.5 {
diff --git a/src/metadata_index.rs b/src/metadata_index.rs
index 928898c..96c771e 100644
--- a/src/metadata_index.rs
+++ b/src/metadata_index.rs
@@ -92,7 +92,7 @@ impl IndexedValue {
                 } else {
                     IndexedValue::Null
                 }
-            }
+            },
             serde_json::Value::Bool(b) => IndexedValue::Bool(*b),
             _ => IndexedValue::Null,
         }
@@ -132,10 +132,7 @@ impl BTreeIndex {
 
     /// Insert value
     pub fn insert(&mut self, value: IndexedValue, id: String) {
-        self.tree
-            .entry(value)
-            .or_default()
-            .insert(id);
+        self.tree.entry(value).or_default().insert(id);
     }
 
     /// Remove value
@@ -157,14 +154,14 @@ impl BTreeIndex {
                 if let Some(ids) = self.tree.get(value) {
                     result.extend(ids.iter().cloned());
                 }
-            }
+            },
             "!=" => {
                 for (k, ids) in &self.tree {
                     if k != value {
                         result.extend(ids.iter().cloned());
                     }
                 }
-            }
+            },
             ">" => {
                 for (_k, ids) in self.tree.range((
                     std::ops::Bound::Excluded(value.clone()),
@@ -172,7 +169,7 @@ impl BTreeIndex {
                 )) {
                     result.extend(ids.iter().cloned());
                 }
-            }
+            },
             ">=" => {
                 for (_k, ids) in self.tree.range((
                     std::ops::Bound::Included(value.clone()),
@@ -180,7 +177,7 @@ impl BTreeIndex {
                 )) {
                     result.extend(ids.iter().cloned());
                 }
-            }
+            },
             "<" => {
                 for (_k, ids) in self.tree.range((
                     std::ops::Bound::Unbounded,
@@ -188,7 +185,7 @@ impl BTreeIndex {
                 )) {
                     result.extend(ids.iter().cloned());
                 }
-            }
+            },
             "<=" => {
                 for (_k, ids) in self.tree.range((
                     std::ops::Bound::Unbounded,
@@ -196,8 +193,8 @@ impl BTreeIndex {
                 )) {
                     result.extend(ids.iter().cloned());
                 }
-            }
-            _ => {}
+            },
+            _ => {},
         }
 
         result
@@ -233,10 +230,7 @@ impl HashIndex {
 
     /// Insert value
     pub fn insert(&mut self, value: IndexedValue, id: String) {
-        self.map
-            .entry(value)
-            .or_default()
-            .insert(id);
+        self.map.entry(value).or_default().insert(id);
     }
 
     /// Remove value
@@ -386,15 +380,15 @@ impl MetadataIndex {
         match self {
             MetadataIndex::BTree(idx) => {
                 idx.insert(IndexedValue::from_json(value), id);
-            }
+            },
             MetadataIndex::Hash(idx) => {
                 idx.insert(IndexedValue::from_json(value), id);
-            }
+            },
             MetadataIndex::Inverted(idx) => {
                 if let serde_json::Value::String(text) = value {
                     idx.insert(text, id);
                 }
-            }
+            },
         }
         Ok(())
     }
@@ -404,15 +398,15 @@ impl MetadataIndex {
         match self {
             MetadataIndex::BTree(idx) => {
                 idx.remove(&IndexedValue::from_json(value), id);
-            }
+            },
             MetadataIndex::Hash(idx) => {
                 idx.remove(&IndexedValue::from_json(value), id);
-            }
+            },
             MetadataIndex::Inverted(idx) => {
                 if let serde_json::Value::String(text) = value {
                     idx.remove(text, id);
                 }
-            }
+            },
         }
         Ok(())
     }
@@ -512,7 +506,7 @@ impl MetadataIndexManager {
                 } else {
                     HashSet::new()
                 }
-            }
+            },
         };
 
         Some(result)
@@ -527,7 +521,7 @@ impl MetadataIndexManager {
                 let indexed_values: Vec<IndexedValue> =
                     values.iter().map(IndexedValue::from_json).collect();
                 Some(idx.query_in(&indexed_values))
-            }
+            },
             _ => None,
         }
     }
@@ -546,17 +540,17 @@ impl MetadataIndexManager {
                 let unique = idx.tree.len();
                 let total = idx.all_ids().len();
                 (IndexType::BTree, unique, total)
-            }
+            },
             MetadataIndex::Hash(idx) => {
                 let unique = idx.map.len();
                 let total = idx.all_ids().len();
                 (IndexType::Hash, unique, total)
-            }
+            },
             MetadataIndex::Inverted(idx) => {
                 let unique = idx.index.len();
                 let total: usize = idx.index.values().map(|s| s.len()).sum();
                 (IndexType::Inverted, unique, total)
-            }
+            },
         };
 
         Some(IndexStats {
diff --git a/src/metrics.rs b/src/metrics.rs
index 6fe7568..26ce272 100644
--- a/src/metrics.rs
+++ b/src/metrics.rs
@@ -42,8 +42,8 @@
 //! let metrics_text = prom.encode()?;
 //! ```
 
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, Instant};
 
 /// Configuration for metrics collection
@@ -556,7 +556,9 @@ struct EmbeddedMetricsInner {
 impl EmbeddedMetrics {
     /// Create a new embedded metrics registry
     pub fn new() -> Self {
-        Self::with_buckets(vec![1.0, 5.0, 10.0, 25.0, 50.0, 100.0, 250.0, 500.0, 1000.0, 5000.0])
+        Self::with_buckets(vec![
+            1.0, 5.0, 10.0, 25.0, 50.0, 100.0, 250.0, 500.0, 1000.0, 5000.0,
+        ])
     }
 
     /// Create with custom latency buckets (in milliseconds)
@@ -608,18 +610,24 @@ impl EmbeddedMetrics {
 
     /// Set the estimated memory usage
     pub fn set_memory_bytes(&self, bytes: u64) {
-        self.inner.estimated_memory_bytes.store(bytes, Ordering::Relaxed);
+        self.inner
+            .estimated_memory_bytes
+            .store(bytes, Ordering::Relaxed);
     }
 
     /// Set HNSW index stats
     pub fn set_hnsw_stats(&self, layers: u64, connections_per_layer: u64) {
         self.inner.hnsw_layers.store(layers, Ordering::Relaxed);
-        self.inner.hnsw_connections_per_layer.store(connections_per_layer, Ordering::Relaxed);
+        self.inner
+            .hnsw_connections_per_layer
+            .store(connections_per_layer, Ordering::Relaxed);
     }
 
     /// Set quantization stats
     pub fn set_quantization_stats(&self, quantized_count: u64, bits: u64) {
-        self.inner.quantized_vectors.store(quantized_count, Ordering::Relaxed);
+        self.inner
+            .quantized_vectors
+            .store(quantized_count, Ordering::Relaxed);
         self.inner.quantization_bits.store(bits, Ordering::Relaxed);
     }
 
@@ -649,9 +657,8 @@ impl EmbeddedMetrics {
             if l.is_empty() {
                 String::new()
             } else {
-                let pairs: Vec<String> = l.iter()
-                    .map(|(k, v)| format!("{}=\"{}\"", k, v))
-                    .collect();
+                let pairs: Vec<String> =
+                    l.iter().map(|(k, v)| format!("{}=\"{}\"", k, v)).collect();
                 format!("{{{}}}", pairs.join(","))
             }
         } else {
@@ -727,7 +734,8 @@ impl EmbeddedMetrics {
         ));
         output.push_str(&format!(
             "vecstore_query_latency_ms_sum{} {:.2}\n",
-            label_str, snapshot.avg_query_latency_micros * snapshot.total_queries as f64 / 1000.0
+            label_str,
+            snapshot.avg_query_latency_micros * snapshot.total_queries as f64 / 1000.0
         ));
         output.push_str(&format!(
             "vecstore_query_latency_ms_count{} {}\n\n",
@@ -780,7 +788,10 @@ impl EmbeddedMetrics {
         ));
 
         let layers = self.inner.hnsw_layers.load(Ordering::Relaxed);
-        let conns = self.inner.hnsw_connections_per_layer.load(Ordering::Relaxed);
+        let conns = self
+            .inner
+            .hnsw_connections_per_layer
+            .load(Ordering::Relaxed);
         output.push_str(&format!(
             "# HELP vecstore_hnsw_layers Number of HNSW layers\n\
              # TYPE vecstore_hnsw_layers gauge\n\
diff --git a/src/migration.rs b/src/migration.rs
index 3431fc5..5128abd 100644
--- a/src/migration.rs
+++ b/src/migration.rs
@@ -39,7 +39,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::HashMap;
@@ -253,7 +253,7 @@ impl Migrator {
                 Err(e) => {
                     stats.add_failure(format!("Line {}: Failed to read line: {}", line_num + 1, e));
                     continue;
-                }
+                },
             };
 
             if line.trim().is_empty() {
@@ -265,15 +265,16 @@ impl Migrator {
                 Ok(record) => {
                     // Validate dimension
                     if let Some(max_dim) = self.max_dimension
-                        && record.vector.len() > max_dim {
-                            stats.add_failure(format!(
-                                "Line {}: Vector dimension {} exceeds maximum {}",
-                                line_num + 1,
-                                record.vector.len(),
-                                max_dim
-                            ));
-                            continue;
-                        }
+                        && record.vector.len() > max_dim
+                    {
+                        stats.add_failure(format!(
+                            "Line {}: Vector dimension {} exceeds maximum {}",
+                            line_num + 1,
+                            record.vector.len(),
+                            max_dim
+                        ));
+                        continue;
+                    }
 
                     // Enforce dimension if specified
                     let record = if let Some(target_dim) = self.enforce_dimension {
@@ -285,14 +286,14 @@ impl Migrator {
                     stats.total_vectors += record.vector.len();
                     records.push(record);
                     stats.add_success();
-                }
+                },
                 Err(e) => {
                     if self.strict_mode {
                         return Err(anyhow!("Line {}: {}", line_num + 1, e));
                     } else {
                         stats.add_failure(format!("Line {}: {}", line_num + 1, e));
                     }
-                }
+                },
             }
         }
 
@@ -315,7 +316,7 @@ impl Migrator {
                     metadata: record.metadata,
                     timestamp: None,
                 })
-            }
+            },
 
             SourceDatabase::Weaviate => {
                 let record: WeaviateRecord = serde_json::from_str(line)?;
@@ -325,7 +326,7 @@ impl Migrator {
                     metadata: record.properties,
                     timestamp: None,
                 })
-            }
+            },
 
             SourceDatabase::Qdrant => {
                 let record: QdrantRecord = serde_json::from_str(line)?;
@@ -341,7 +342,7 @@ impl Migrator {
                     metadata: record.payload,
                     timestamp: None,
                 })
-            }
+            },
 
             SourceDatabase::ChromaDB => {
                 let record: ChromaRecord = serde_json::from_str(line)?;
@@ -358,7 +359,7 @@ impl Migrator {
                     metadata,
                     timestamp: None,
                 })
-            }
+            },
 
             SourceDatabase::Milvus => {
                 let record: MilvusRecord = serde_json::from_str(line)?;
@@ -374,13 +375,13 @@ impl Migrator {
                     metadata: record.fields,
                     timestamp: None,
                 })
-            }
+            },
 
             SourceDatabase::Generic => {
                 // Try to parse as generic migration record
                 serde_json::from_str(line)
                     .map_err(|e| anyhow!("Failed to parse generic record: {}", e))
-            }
+            },
         }
     }
 
@@ -483,7 +484,7 @@ impl Migrator {
                 Err(e) => {
                     stats.add_failure(format!("Line {}: Failed to read: {}", line_num + 2, e));
                     continue;
-                }
+                },
             };
 
             let parts: Vec<&str> = line.split(',').collect();
@@ -506,7 +507,7 @@ impl Migrator {
                             e
                         ));
                         continue;
-                    }
+                    },
                 }
             }
 
diff --git a/src/ml_ranking.rs b/src/ml_ranking.rs
index 664685e..24195ae 100644
--- a/src/ml_ranking.rs
+++ b/src/ml_ranking.rs
@@ -36,16 +36,16 @@ use serde::{Deserialize, Serialize};
 
 use crate::error::Result;
 
-#[cfg(feature = "embeddings")]
-use std::path::Path;
-#[cfg(feature = "embeddings")]
-use std::sync::{Arc, Mutex, RwLock};
 #[cfg(feature = "embeddings")]
 use crate::error::VecStoreError;
 #[cfg(feature = "embeddings")]
 use ndarray::Array2;
 #[cfg(feature = "embeddings")]
-use ort::session::{builder::GraphOptimizationLevel, Session};
+use ort::session::{Session, builder::GraphOptimizationLevel};
+#[cfg(feature = "embeddings")]
+use std::path::Path;
+#[cfg(feature = "embeddings")]
+use std::sync::{Arc, Mutex, RwLock};
 
 /// Default batch size for ONNX inference
 const DEFAULT_BATCH_SIZE: usize = 32;
@@ -69,10 +69,16 @@ impl OnnxSessionCache {
     }
 
     /// Get or create a session for a model path
-    fn get_or_create_session(&self, model_path: &str, num_threads: usize) -> Result<Arc<Mutex<Session>>> {
+    fn get_or_create_session(
+        &self,
+        model_path: &str,
+        num_threads: usize,
+    ) -> Result<Arc<Mutex<Session>>> {
         // Check if session already exists
         {
-            let sessions = self.sessions.read()
+            let sessions = self
+                .sessions
+                .read()
                 .map_err(|e| VecStoreError::LockError(e.to_string()))?;
             if let Some(session) = sessions.get(model_path) {
                 return Ok(Arc::clone(session));
@@ -82,13 +88,20 @@ impl OnnxSessionCache {
         // Create new session using ort 2.0 API
         let path = Path::new(model_path);
         if !path.exists() {
-            return Err(VecStoreError::NotFound(format!("Model file not found: {}", model_path)));
+            return Err(VecStoreError::NotFound(format!(
+                "Model file not found: {}",
+                model_path
+            )));
         }
 
         let session = Session::builder()
-            .map_err(|e| VecStoreError::Internal(format!("Failed to create session builder: {}", e)))?
+            .map_err(|e| {
+                VecStoreError::Internal(format!("Failed to create session builder: {}", e))
+            })?
             .with_optimization_level(GraphOptimizationLevel::Level3)
-            .map_err(|e| VecStoreError::Internal(format!("Failed to set optimization level: {}", e)))?
+            .map_err(|e| {
+                VecStoreError::Internal(format!("Failed to set optimization level: {}", e))
+            })?
             .with_intra_threads(num_threads)
             .map_err(|e| VecStoreError::Internal(format!("Failed to set thread count: {}", e)))?
             .commit_from_file(path)
@@ -98,7 +111,9 @@ impl OnnxSessionCache {
 
         // Cache the session
         {
-            let mut sessions = self.sessions.write()
+            let mut sessions = self
+                .sessions
+                .write()
                 .map_err(|e| VecStoreError::LockError(e.to_string()))?;
 
             // Evict oldest if cache is full
@@ -124,13 +139,16 @@ impl OnnxSessionCache {
             .map_err(|e| VecStoreError::Internal(format!("Failed to create dummy input: {}", e)))?;
 
         // Create Tensor object for ort 2.0
-        let input_tensor = ort::value::Tensor::from_array(input_array)
-            .map_err(|e| VecStoreError::Internal(format!("Failed to create input tensor: {}", e)))?;
+        let input_tensor = ort::value::Tensor::from_array(input_array).map_err(|e| {
+            VecStoreError::Internal(format!("Failed to create input tensor: {}", e))
+        })?;
 
         // Run warmup inference using ort 2.0 inputs! macro
-        let mut session_guard = session.lock()
+        let mut session_guard = session
+            .lock()
             .map_err(|e| VecStoreError::LockError(e.to_string()))?;
-        let _ = session_guard.run(ort::inputs![input_tensor])
+        let _ = session_guard
+            .run(ort::inputs![input_tensor])
             .map_err(|e| VecStoreError::Internal(format!("Warmup inference failed: {}", e)))?;
 
         Ok(())
@@ -138,7 +156,9 @@ impl OnnxSessionCache {
 
     /// Clear all cached sessions
     fn clear(&self) -> Result<()> {
-        let mut sessions = self.sessions.write()
+        let mut sessions = self
+            .sessions
+            .write()
             .map_err(|e| VecStoreError::LockError(e.to_string()))?;
         sessions.clear();
         Ok(())
@@ -156,7 +176,9 @@ fn get_session_cache() -> Result<&'static OnnxSessionCache> {
     let cache = OnnxSessionCache::new()?;
     // Ignore the result if another thread initialized first
     let _ = CACHE.set(cache);
-    CACHE.get().ok_or_else(|| VecStoreError::Internal("Failed to initialize session cache".to_string()))
+    CACHE
+        .get()
+        .ok_or_else(|| VecStoreError::Internal("Failed to initialize session cache".to_string()))
 }
 
 /// Ranking configuration
@@ -188,11 +210,21 @@ pub struct RankingConfig {
     pub warmup_models: bool,
 }
 
-fn default_top_k() -> usize { 100 }
-fn default_final_k() -> usize { 10 }
-fn default_true() -> bool { true }
-fn default_batch_size() -> usize { DEFAULT_BATCH_SIZE }
-fn default_num_threads() -> usize { 4 }
+fn default_top_k() -> usize {
+    100
+}
+fn default_final_k() -> usize {
+    10
+}
+fn default_true() -> bool {
+    true
+}
+fn default_batch_size() -> usize {
+    DEFAULT_BATCH_SIZE
+}
+fn default_num_threads() -> usize {
+    4
+}
 
 impl Default for RankingConfig {
     fn default() -> Self {
@@ -263,8 +295,7 @@ pub enum ScoreNormalization {
 }
 
 /// Model type for ONNX inference
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[derive(Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub enum OnnxModelType {
     /// Generic ranking model (outputs a single relevance score)
     #[default]
@@ -279,7 +310,6 @@ pub enum OnnxModelType {
     NeuralNetwork,
 }
 
-
 /// ONNX model configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct OnnxModelConfig {
@@ -308,8 +338,12 @@ pub struct OnnxModelConfig {
     pub output_index: usize,
 }
 
-fn default_input_name() -> String { "input".to_string() }
-fn default_output_name() -> String { "output".to_string() }
+fn default_input_name() -> String {
+    "input".to_string()
+}
+fn default_output_name() -> String {
+    "output".to_string()
+}
 
 impl OnnxModelConfig {
     /// Create a new ONNX model config
@@ -409,14 +443,9 @@ pub enum RankingModel {
         num_features: usize,
     },
     /// Linear model
-    Linear {
-        weights: Vec<f32>,
-        bias: f32,
-    },
+    Linear { weights: Vec<f32>, bias: f32 },
     /// Custom scoring function
-    Custom {
-        name: String,
-    },
+    Custom { name: String },
 }
 
 impl RankingModel {
@@ -631,9 +660,10 @@ impl MLRanker {
         let candidates_with_features: Vec<(RankingCandidate, RankingFeatures)> = candidates
             .into_iter()
             .map(|c| {
-                let features = c.features.clone().unwrap_or_else(|| {
-                    self.compute_features(query, &c)
-                });
+                let features = c
+                    .features
+                    .clone()
+                    .unwrap_or_else(|| self.compute_features(query, &c));
                 (c, features)
             })
             .collect();
@@ -660,19 +690,21 @@ impl MLRanker {
     ) -> Result<Vec<RankedResult>> {
         if self.models.is_empty() {
             // No models - just use original scores
-            return Ok(candidates.iter().map(|(c, features)| {
-                RankedResult {
+            return Ok(candidates
+                .iter()
+                .map(|(c, features)| RankedResult {
                     id: c.id.clone(),
                     score: c.original_score,
                     original_score: c.original_score,
                     feature_contributions: Some(self.get_feature_contributions(features)),
                     metadata: c.metadata.clone(),
-                }
-            }).collect());
+                })
+                .collect());
         }
 
         // Collect all feature vectors
-        let feature_vectors: Vec<Vec<f32>> = candidates.iter()
+        let feature_vectors: Vec<Vec<f32>> = candidates
+            .iter()
             .map(|(_, features)| features.to_vector())
             .collect();
 
@@ -685,16 +717,17 @@ impl MLRanker {
         }
 
         // Combine scores for each candidate
-        let results: Vec<RankedResult> = candidates.iter()
+        let results: Vec<RankedResult> = candidates
+            .iter()
             .enumerate()
             .map(|(idx, (c, features))| {
-                let model_scores: Vec<f32> = all_model_scores.iter()
-                    .map(|scores| scores[idx])
-                    .collect();
+                let model_scores: Vec<f32> =
+                    all_model_scores.iter().map(|scores| scores[idx]).collect();
 
                 let final_score = if self.config.ensemble_weights.len() == model_scores.len() {
                     // Weighted ensemble
-                    model_scores.iter()
+                    model_scores
+                        .iter()
                         .zip(&self.config.ensemble_weights)
                         .map(|(s, w)| s * w)
                         .sum()
@@ -723,30 +756,40 @@ impl MLRanker {
         feature_vectors: &[Vec<f32>],
     ) -> Result<Vec<f32>> {
         match model {
-            RankingModel::Linear { weights, bias } => {
-                Ok(feature_vectors.iter().map(|fv| {
-                    let score: f32 = fv.iter()
+            RankingModel::Linear { weights, bias } => Ok(feature_vectors
+                .iter()
+                .map(|fv| {
+                    let score: f32 = fv
+                        .iter()
                         .zip(weights.iter())
                         .map(|(f, w)| f * w)
-                        .sum::<f32>() + bias;
+                        .sum::<f32>()
+                        + bias;
                     self.sigmoid(score)
-                }).collect())
-            }
-            RankingModel::ONNX(config) => {
-                self.score_batch_onnx(&config.path, feature_vectors, config.apply_sigmoid, config.apply_softmax, config.output_index)
-            }
+                })
+                .collect()),
+            RankingModel::ONNX(config) => self.score_batch_onnx(
+                &config.path,
+                feature_vectors,
+                config.apply_sigmoid,
+                config.apply_softmax,
+                config.output_index,
+            ),
             RankingModel::XGBoost { path, .. } => {
                 // XGBoost exported to ONNX - apply sigmoid for binary classification
                 self.score_batch_onnx(path, feature_vectors, true, false, 0)
-            }
+            },
             RankingModel::LightGBM { path, .. } => {
                 // LightGBM exported to ONNX - apply sigmoid for binary classification
                 self.score_batch_onnx(path, feature_vectors, true, false, 0)
-            }
+            },
             RankingModel::Custom { .. } => {
                 // Custom models just return original scores (first feature)
-                Ok(feature_vectors.iter().map(|fv| fv.first().copied().unwrap_or(0.0)).collect())
-            }
+                Ok(feature_vectors
+                    .iter()
+                    .map(|fv| fv.first().copied().unwrap_or(0.0))
+                    .collect())
+            },
         }
     }
 
@@ -772,9 +815,16 @@ impl MLRanker {
 
         // Process in batches
         for chunk in feature_vectors.chunks(batch_size) {
-            let mut session_guard = session.lock()
+            let mut session_guard = session
+                .lock()
                 .map_err(|e| VecStoreError::LockError(e.to_string()))?;
-            let batch_scores = self.run_onnx_batch(&mut session_guard, chunk, apply_sigmoid, apply_softmax, output_index)?;
+            let batch_scores = self.run_onnx_batch(
+                &mut session_guard,
+                chunk,
+                apply_sigmoid,
+                apply_softmax,
+                output_index,
+            )?;
             all_scores.extend(batch_scores);
         }
 
@@ -799,26 +849,27 @@ impl MLRanker {
         let feature_dim = batch[0].len();
 
         // Flatten features into a single vector
-        let flat_features: Vec<f32> = batch.iter()
-            .flat_map(|v| v.iter().copied())
-            .collect();
+        let flat_features: Vec<f32> = batch.iter().flat_map(|v| v.iter().copied()).collect();
 
         // Create input array
         let input_array = Array2::from_shape_vec((batch_size, feature_dim), flat_features)
             .map_err(|e| VecStoreError::Internal(format!("Failed to create input array: {}", e)))?;
 
         // Create Tensor object for ort 2.0
-        let input_tensor = ort::value::Tensor::from_array(input_array)
-            .map_err(|e| VecStoreError::Internal(format!("Failed to create input tensor: {}", e)))?;
+        let input_tensor = ort::value::Tensor::from_array(input_array).map_err(|e| {
+            VecStoreError::Internal(format!("Failed to create input tensor: {}", e))
+        })?;
 
         // Run inference using ort 2.0 inputs! macro
-        let outputs = session.run(ort::inputs![input_tensor])
+        let outputs = session
+            .run(ort::inputs![input_tensor])
             .map_err(|e| VecStoreError::Internal(format!("ONNX inference failed: {}", e)))?;
 
         // Extract output tensor using ort 2.0 API
         let output_tensor = &outputs[0];
 
-        let output_view = output_tensor.try_extract_array::<f32>()
+        let output_view = output_tensor
+            .try_extract_array::<f32>()
             .map_err(|e| VecStoreError::Internal(format!("Failed to extract output: {}", e)))?;
         let output_array = output_view.to_owned();
 
@@ -850,12 +901,14 @@ impl MLRanker {
             // Apply softmax across classes, then extract target class
             let num_classes = output_shape[1];
             let actual_index = output_index.min(num_classes - 1);
-            (0..batch_size).map(|i| {
-                let row: Vec<f32> = (0..num_classes).map(|j| output_array[[i, j]]).collect();
-                let max_val = row.iter().fold(f32::NEG_INFINITY, |a, &b| a.max(b));
-                let exp_sum: f32 = row.iter().map(|&x| (x - max_val).exp()).sum();
-                (row[actual_index] - max_val).exp() / exp_sum
-            }).collect()
+            (0..batch_size)
+                .map(|i| {
+                    let row: Vec<f32> = (0..num_classes).map(|j| output_array[[i, j]]).collect();
+                    let max_val = row.iter().fold(f32::NEG_INFINITY, |a, &b| a.max(b));
+                    let exp_sum: f32 = row.iter().map(|&x| (x - max_val).exp()).sum();
+                    (row[actual_index] - max_val).exp() / exp_sum
+                })
+                .collect()
         } else if apply_sigmoid {
             scores.iter().map(|&x| self.sigmoid(x)).collect()
         } else {
@@ -876,7 +929,8 @@ impl MLRanker {
         _output_index: usize,
     ) -> Result<Vec<f32>> {
         // Without embeddings feature, just return the first feature (vector_score)
-        Ok(feature_vectors.iter()
+        Ok(feature_vectors
+            .iter()
             .map(|fv| fv.first().copied().unwrap_or(0.0))
             .collect())
     }
@@ -890,7 +944,8 @@ impl MLRanker {
 
         if !query.is_empty() && !candidate.vector.is_empty() {
             // Dot product
-            let dot: f32 = query.iter()
+            let dot: f32 = query
+                .iter()
                 .zip(candidate.vector.iter())
                 .map(|(q, d)| q * d)
                 .sum();
@@ -913,45 +968,54 @@ impl MLRanker {
             qd_features.push(cosine);
 
             // Max element-wise product
-            let max_sim: f32 = query.iter()
+            let max_sim: f32 = query
+                .iter()
                 .zip(candidate.vector.iter())
                 .map(|(q, d)| q * d)
                 .fold(f32::NEG_INFINITY, f32::max);
             qd_features.push(max_sim);
 
             // Min element-wise product
-            let min_sim: f32 = query.iter()
+            let min_sim: f32 = query
+                .iter()
                 .zip(candidate.vector.iter())
                 .map(|(q, d)| q * d)
                 .fold(f32::INFINITY, f32::min);
             qd_features.push(min_sim);
 
             // Mean element-wise product
-            let mean_sim: f32 = query.iter()
+            let mean_sim: f32 = query
+                .iter()
                 .zip(candidate.vector.iter())
                 .map(|(q, d)| q * d)
-                .sum::<f32>() / query.len().max(1) as f32;
+                .sum::<f32>()
+                / query.len().max(1) as f32;
             qd_features.push(mean_sim);
 
             // Std of element-wise products
-            let products: Vec<f32> = query.iter()
+            let products: Vec<f32> = query
+                .iter()
                 .zip(candidate.vector.iter())
                 .map(|(q, d)| q * d)
                 .collect();
-            let variance: f32 = products.iter()
+            let variance: f32 = products
+                .iter()
                 .map(|&p| (p - mean_sim).powi(2))
-                .sum::<f32>() / products.len().max(1) as f32;
+                .sum::<f32>()
+                / products.len().max(1) as f32;
             qd_features.push(variance.sqrt());
 
             // L1 distance (Manhattan)
-            let l1_dist: f32 = query.iter()
+            let l1_dist: f32 = query
+                .iter()
                 .zip(candidate.vector.iter())
                 .map(|(q, d)| (q - d).abs())
                 .sum();
             qd_features.push(l1_dist);
 
             // L2 distance (Euclidean)
-            let l2_dist: f32 = query.iter()
+            let l2_dist: f32 = query
+                .iter()
                 .zip(candidate.vector.iter())
                 .map(|(q, d)| (q - d).powi(2))
                 .sum::<f32>()
@@ -959,8 +1023,7 @@ impl MLRanker {
             qd_features.push(l2_dist);
         }
 
-        RankingFeatures::new(vector_score)
-            .with_qd_features(qd_features)
+        RankingFeatures::new(vector_score).with_qd_features(qd_features)
     }
 
     /// Get feature contributions for explainability
@@ -973,13 +1036,21 @@ impl MLRanker {
         }
 
         let qd_feature_names = [
-            "dot_product", "query_norm", "doc_norm", "cosine_similarity",
-            "max_product", "min_product", "mean_product", "std_product",
-            "l1_distance", "l2_distance"
+            "dot_product",
+            "query_norm",
+            "doc_norm",
+            "cosine_similarity",
+            "max_product",
+            "min_product",
+            "mean_product",
+            "std_product",
+            "l1_distance",
+            "l2_distance",
         ];
 
         for (i, &f) in features.qd_features.iter().enumerate() {
-            let name = qd_feature_names.get(i)
+            let name = qd_feature_names
+                .get(i)
                 .map(|s| s.to_string())
                 .unwrap_or_else(|| format!("qd_feature_{}", i));
             contributions.insert(name, f);
@@ -1003,36 +1074,47 @@ impl MLRanker {
         }
 
         match self.config.normalization {
-            ScoreNormalization::None => {}
+            ScoreNormalization::None => {},
             ScoreNormalization::MinMax => {
-                let min = results.iter().map(|r| r.score).fold(f32::INFINITY, f32::min);
-                let max = results.iter().map(|r| r.score).fold(f32::NEG_INFINITY, f32::max);
+                let min = results
+                    .iter()
+                    .map(|r| r.score)
+                    .fold(f32::INFINITY, f32::min);
+                let max = results
+                    .iter()
+                    .map(|r| r.score)
+                    .fold(f32::NEG_INFINITY, f32::max);
                 let range = max - min;
                 if range > 0.0 {
                     for r in results {
                         r.score = (r.score - min) / range;
                     }
                 }
-            }
+            },
             ScoreNormalization::ZScore => {
                 let mean: f32 = results.iter().map(|r| r.score).sum::<f32>() / results.len() as f32;
-                let variance: f32 = results.iter()
+                let variance: f32 = results
+                    .iter()
                     .map(|r| (r.score - mean).powi(2))
-                    .sum::<f32>() / results.len() as f32;
+                    .sum::<f32>()
+                    / results.len() as f32;
                 let std = variance.sqrt();
                 if std > 0.0 {
                     for r in results {
                         r.score = (r.score - mean) / std;
                     }
                 }
-            }
+            },
             ScoreNormalization::Softmax => {
-                let max = results.iter().map(|r| r.score).fold(f32::NEG_INFINITY, f32::max);
+                let max = results
+                    .iter()
+                    .map(|r| r.score)
+                    .fold(f32::NEG_INFINITY, f32::max);
                 let exp_sum: f32 = results.iter().map(|r| (r.score - max).exp()).sum();
                 for r in results {
                     r.score = (r.score - max).exp() / exp_sum;
                 }
-            }
+            },
         }
     }
 
@@ -1074,12 +1156,7 @@ impl RankingPipeline {
     }
 
     /// Add a ranking stage
-    pub fn add_stage(
-        &mut self,
-        name: impl Into<String>,
-        ranker: MLRanker,
-        top_k: usize,
-    ) {
+    pub fn add_stage(&mut self, name: impl Into<String>, ranker: MLRanker, top_k: usize) {
         self.stages.push(RankingStage {
             name: name.into(),
             ranker,
@@ -1099,7 +1176,8 @@ impl RankingPipeline {
             let results = stage.ranker.rerank(query, candidates)?;
 
             // Convert results back to candidates for next stage
-            candidates = results.into_iter()
+            candidates = results
+                .into_iter()
                 .take(stage.top_k)
                 .map(|r| RankingCandidate {
                     id: r.id,
@@ -1115,7 +1193,8 @@ impl RankingPipeline {
         if let Some(last_stage) = self.stages.last_mut() {
             last_stage.ranker.rerank(query, candidates)
         } else {
-            Ok(candidates.into_iter()
+            Ok(candidates
+                .into_iter()
                 .map(|c| RankedResult {
                     id: c.id,
                     score: c.original_score,
@@ -1281,9 +1360,7 @@ mod tests {
 
     #[test]
     fn test_no_models_uses_original_scores() {
-        let config = RankingConfig::new()
-            .with_final_k(10)
-            .with_warmup(false);
+        let config = RankingConfig::new().with_final_k(10).with_warmup(false);
         let mut ranker = MLRanker::new(config).unwrap();
 
         let candidates: Vec<RankingCandidate> = vec![
@@ -1314,9 +1391,7 @@ mod tests {
 
     #[test]
     fn test_batch_size_config() {
-        let config = RankingConfig::new()
-            .with_batch_size(64)
-            .with_num_threads(8);
+        let config = RankingConfig::new().with_batch_size(64).with_num_threads(8);
 
         assert_eq!(config.batch_size, 64);
         assert_eq!(config.num_threads, 8);
@@ -1403,12 +1478,8 @@ mod tests {
 
     #[test]
     fn test_pipeline_execution() {
-        let config1 = RankingConfig::new()
-            .with_final_k(5)
-            .with_warmup(false);
-        let config2 = RankingConfig::new()
-            .with_final_k(3)
-            .with_warmup(false);
+        let config1 = RankingConfig::new().with_final_k(5).with_warmup(false);
+        let config2 = RankingConfig::new().with_final_k(3).with_warmup(false);
 
         let ranker1 = MLRanker::new(config1).unwrap();
         let ranker2 = MLRanker::new(config2).unwrap();
diff --git a/src/monitoring.rs b/src/monitoring.rs
index 3fab4b2..ae79a51 100644
--- a/src/monitoring.rs
+++ b/src/monitoring.rs
@@ -101,7 +101,7 @@ impl AlertCondition {
             AlertCondition::NotEqual => (value - threshold).abs() >= 1e-6,
             AlertCondition::PercentageChange => {
                 (value / threshold - 1.0).abs() > 0.1 // 10% change
-            }
+            },
         }
     }
 }
@@ -312,9 +312,10 @@ impl Monitor {
             // Check cooldown period
             if let Some(last_time) = self.last_alert_time.get(&rule.name)
                 && let Ok(elapsed) = SystemTime::now().duration_since(*last_time)
-                    && elapsed < self.config.alert_cooldown {
-                        continue;
-                    }
+                && elapsed < self.config.alert_cooldown
+            {
+                continue;
+            }
 
             // Evaluate condition
             if rule.condition.evaluate(value, rule.threshold) {
diff --git a/src/multi_vector.rs b/src/multi_vector.rs
index 5a57b01..9ceca93 100644
--- a/src/multi_vector.rs
+++ b/src/multi_vector.rs
@@ -57,7 +57,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -213,10 +213,7 @@ impl MultiVectorIndex {
                 let token_vec = &self.token_vectors[token_id];
                 let sim = cosine_similarity(query_vec, token_vec);
 
-                doc_scores
-                    .entry(doc_id.clone())
-                    .or_default()
-                    .push(sim);
+                doc_scores.entry(doc_id.clone()).or_default().push(sim);
             }
         }
 
@@ -227,7 +224,7 @@ impl MultiVectorIndex {
                 let score = match self.aggregation {
                     AggregationMethod::MaxSim => {
                         sims.iter().copied().fold(f32::NEG_INFINITY, f32::max)
-                    }
+                    },
                     AggregationMethod::AvgSim => sims.iter().sum::<f32>() / sims.len() as f32,
                     AggregationMethod::SumSim => sims.iter().sum(),
                     AggregationMethod::FirstToken => sims.first().copied().unwrap_or(0.0),
@@ -607,7 +604,7 @@ impl OptimizedMultiVectorIndex {
                 let score = match self.aggregation {
                     AggregationMethod::MaxSim => {
                         sims.iter().copied().fold(f32::NEG_INFINITY, f32::max)
-                    }
+                    },
                     AggregationMethod::AvgSim => sims.iter().sum::<f32>() / sims.len() as f32,
                     AggregationMethod::SumSim => sims.iter().sum(),
                     AggregationMethod::FirstToken => sims.first().copied().unwrap_or(0.0),
@@ -729,7 +726,7 @@ impl LateInteractionScorer {
             ScoreMode::SumMaxSim => maxsim_per_query.iter().sum(),
             ScoreMode::AvgMaxSim => {
                 maxsim_per_query.iter().sum::<f32>() / maxsim_per_query.len() as f32
-            }
+            },
             ScoreMode::MaxMaxSim => maxsim_per_query
                 .iter()
                 .copied()
diff --git a/src/multilang.rs b/src/multilang.rs
index 36aeb4b..7f6b97e 100644
--- a/src/multilang.rs
+++ b/src/multilang.rs
@@ -21,9 +21,8 @@
 //! // ["gato", "corr", "rapid"] - stemmed, no stopwords
 //! ```
 
-use std::collections::{HashMap, HashSet};
 use serde::{Deserialize, Serialize};
-
+use std::collections::{HashMap, HashSet};
 
 /// Supported languages
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -161,15 +160,33 @@ impl Language {
     /// Get all supported languages
     pub fn all() -> Vec<Language> {
         vec![
-            Language::English, Language::Spanish, Language::French,
-            Language::German, Language::Italian, Language::Portuguese,
-            Language::Dutch, Language::Swedish, Language::Norwegian,
-            Language::Danish, Language::Finnish, Language::Russian,
-            Language::Arabic, Language::Turkish, Language::Chinese,
-            Language::Japanese, Language::Korean, Language::Greek,
-            Language::Hebrew, Language::Hindi, Language::Thai,
-            Language::Vietnamese, Language::Polish, Language::Czech,
-            Language::Hungarian, Language::Romanian, Language::Indonesian,
+            Language::English,
+            Language::Spanish,
+            Language::French,
+            Language::German,
+            Language::Italian,
+            Language::Portuguese,
+            Language::Dutch,
+            Language::Swedish,
+            Language::Norwegian,
+            Language::Danish,
+            Language::Finnish,
+            Language::Russian,
+            Language::Arabic,
+            Language::Turkish,
+            Language::Chinese,
+            Language::Japanese,
+            Language::Korean,
+            Language::Greek,
+            Language::Hebrew,
+            Language::Hindi,
+            Language::Thai,
+            Language::Vietnamese,
+            Language::Polish,
+            Language::Czech,
+            Language::Hungarian,
+            Language::Romanian,
+            Language::Indonesian,
         ]
     }
 }
@@ -177,69 +194,79 @@ impl Language {
 /// Stopwords for each language
 fn get_stopwords(lang: Language) -> HashSet<&'static str> {
     match lang {
-        Language::English => {
-            ["a", "an", "the", "and", "or", "but", "in", "on", "at", "to", "for",
-             "of", "with", "by", "from", "as", "is", "was", "are", "were", "been",
-             "be", "have", "has", "had", "do", "does", "did", "will", "would",
-             "could", "should", "may", "might", "must", "can", "this", "that",
-             "these", "those", "i", "you", "he", "she", "it", "we", "they",
-             "what", "which", "who", "when", "where", "why", "how", "all",
-             "each", "every", "both", "few", "more", "most", "other", "some",
-             "such", "no", "not", "only", "same", "so", "than", "too", "very"]
-                .iter().cloned().collect()
-        }
-        Language::Spanish => {
-            ["de", "la", "que", "el", "en", "y", "a", "los", "del", "se",
-             "las", "por", "un", "para", "con", "no", "una", "su", "al",
-             "es", "lo", "como", "más", "pero", "sus", "le", "ya", "o",
-             "fue", "este", "ha", "sí", "porque", "esta", "son", "entre",
-             "está", "cuando", "muy", "sin", "sobre", "ser", "tiene", "también"]
-                .iter().cloned().collect()
-        }
-        Language::French => {
-            ["le", "la", "les", "de", "du", "des", "un", "une", "et", "en",
-             "à", "au", "aux", "ce", "que", "qui", "dans", "pour", "sur",
-             "par", "avec", "ne", "pas", "plus", "ou", "son", "sa", "ses",
-             "il", "elle", "nous", "vous", "ils", "elles", "je", "tu",
-             "est", "sont", "être", "avoir", "fait", "faire", "comme"]
-                .iter().cloned().collect()
-        }
-        Language::German => {
-            ["der", "die", "das", "und", "in", "zu", "den", "von", "mit",
-             "ist", "nicht", "ein", "eine", "als", "auch", "es", "an",
-             "auf", "für", "sich", "des", "dem", "werden", "bei", "haben",
-             "wird", "sind", "oder", "nach", "am", "um", "aus", "nur",
-             "wie", "über", "so", "wenn", "aber", "noch", "durch", "kann"]
-                .iter().cloned().collect()
-        }
-        Language::Italian => {
-            ["il", "lo", "la", "i", "gli", "le", "un", "uno", "una", "di",
-             "a", "da", "in", "con", "su", "per", "tra", "fra", "che",
-             "e", "ma", "o", "se", "come", "non", "più", "anche", "solo",
-             "questo", "quello", "suo", "loro", "essere", "avere", "fare"]
-                .iter().cloned().collect()
-        }
-        Language::Russian => {
-            ["и", "в", "не", "на", "я", "что", "он", "с", "это", "а",
-             "как", "она", "по", "но", "они", "к", "у", "ты", "из", "мы",
-             "за", "от", "о", "же", "все", "так", "его", "её", "их"]
-                .iter().cloned().collect()
-        }
-        Language::Arabic => {
-            ["في", "من", "على", "إلى", "عن", "مع", "هذا", "هذه", "التي",
-             "الذي", "كان", "لم", "لا", "ما", "هو", "هي", "أن", "أو",
-             "و", "ثم", "بعد", "قبل", "كل", "بين", "حتى", "إذا"]
-                .iter().cloned().collect()
-        }
+        Language::English => [
+            "a", "an", "the", "and", "or", "but", "in", "on", "at", "to", "for", "of", "with",
+            "by", "from", "as", "is", "was", "are", "were", "been", "be", "have", "has", "had",
+            "do", "does", "did", "will", "would", "could", "should", "may", "might", "must", "can",
+            "this", "that", "these", "those", "i", "you", "he", "she", "it", "we", "they", "what",
+            "which", "who", "when", "where", "why", "how", "all", "each", "every", "both", "few",
+            "more", "most", "other", "some", "such", "no", "not", "only", "same", "so", "than",
+            "too", "very",
+        ]
+        .iter()
+        .cloned()
+        .collect(),
+        Language::Spanish => [
+            "de", "la", "que", "el", "en", "y", "a", "los", "del", "se", "las", "por", "un",
+            "para", "con", "no", "una", "su", "al", "es", "lo", "como", "más", "pero", "sus", "le",
+            "ya", "o", "fue", "este", "ha", "sí", "porque", "esta", "son", "entre", "está",
+            "cuando", "muy", "sin", "sobre", "ser", "tiene", "también",
+        ]
+        .iter()
+        .cloned()
+        .collect(),
+        Language::French => [
+            "le", "la", "les", "de", "du", "des", "un", "une", "et", "en", "à", "au", "aux", "ce",
+            "que", "qui", "dans", "pour", "sur", "par", "avec", "ne", "pas", "plus", "ou", "son",
+            "sa", "ses", "il", "elle", "nous", "vous", "ils", "elles", "je", "tu", "est", "sont",
+            "être", "avoir", "fait", "faire", "comme",
+        ]
+        .iter()
+        .cloned()
+        .collect(),
+        Language::German => [
+            "der", "die", "das", "und", "in", "zu", "den", "von", "mit", "ist", "nicht", "ein",
+            "eine", "als", "auch", "es", "an", "auf", "für", "sich", "des", "dem", "werden", "bei",
+            "haben", "wird", "sind", "oder", "nach", "am", "um", "aus", "nur", "wie", "über", "so",
+            "wenn", "aber", "noch", "durch", "kann",
+        ]
+        .iter()
+        .cloned()
+        .collect(),
+        Language::Italian => [
+            "il", "lo", "la", "i", "gli", "le", "un", "uno", "una", "di", "a", "da", "in", "con",
+            "su", "per", "tra", "fra", "che", "e", "ma", "o", "se", "come", "non", "più", "anche",
+            "solo", "questo", "quello", "suo", "loro", "essere", "avere", "fare",
+        ]
+        .iter()
+        .cloned()
+        .collect(),
+        Language::Russian => [
+            "и", "в", "не", "на", "я", "что", "он", "с", "это", "а", "как", "она", "по", "но",
+            "они", "к", "у", "ты", "из", "мы", "за", "от", "о", "же", "все", "так", "его", "её",
+            "их",
+        ]
+        .iter()
+        .cloned()
+        .collect(),
+        Language::Arabic => [
+            "في", "من", "على", "إلى", "عن", "مع", "هذا", "هذه", "التي", "الذي", "كان", "لم", "لا",
+            "ما", "هو", "هي", "أن", "أو", "و", "ثم", "بعد", "قبل", "كل", "بين", "حتى", "إذا",
+        ]
+        .iter()
+        .cloned()
+        .collect(),
         Language::Chinese | Language::Japanese | Language::Korean => {
             // CJK languages typically don't use stopword removal
             HashSet::new()
-        }
+        },
         _ => {
             // Default minimal stopwords
             ["a", "an", "the", "and", "or", "but", "in", "on", "at", "to"]
-                .iter().cloned().collect()
-        }
+                .iter()
+                .cloned()
+                .collect()
+        },
     }
 }
 
@@ -255,58 +282,120 @@ impl StemmingRules {
         match lang {
             Language::English => Self {
                 suffixes: vec![
-                    ("ational", "ate"), ("tional", "tion"), ("enci", "ence"),
-                    ("anci", "ance"), ("izer", "ize"), ("isation", "ize"),
-                    ("ization", "ize"), ("ation", "ate"), ("ator", "ate"),
-                    ("alism", "al"), ("iveness", "ive"), ("fulness", "ful"),
-                    ("ousness", "ous"), ("aliti", "al"), ("iviti", "ive"),
-                    ("biliti", "ble"), ("alli", "al"), ("entli", "ent"),
-                    ("eli", "e"), ("ousli", "ous"), ("ling", ""),
-                    ("ement", ""), ("ment", ""), ("ness", ""), ("ing", ""),
-                    ("ies", "y"), ("es", ""), ("ed", ""), ("s", ""),
+                    ("ational", "ate"),
+                    ("tional", "tion"),
+                    ("enci", "ence"),
+                    ("anci", "ance"),
+                    ("izer", "ize"),
+                    ("isation", "ize"),
+                    ("ization", "ize"),
+                    ("ation", "ate"),
+                    ("ator", "ate"),
+                    ("alism", "al"),
+                    ("iveness", "ive"),
+                    ("fulness", "ful"),
+                    ("ousness", "ous"),
+                    ("aliti", "al"),
+                    ("iviti", "ive"),
+                    ("biliti", "ble"),
+                    ("alli", "al"),
+                    ("entli", "ent"),
+                    ("eli", "e"),
+                    ("ousli", "ous"),
+                    ("ling", ""),
+                    ("ement", ""),
+                    ("ment", ""),
+                    ("ness", ""),
+                    ("ing", ""),
+                    ("ies", "y"),
+                    ("es", ""),
+                    ("ed", ""),
+                    ("s", ""),
                 ],
                 min_stem_length: 3,
             },
             Language::Spanish => Self {
                 suffixes: vec![
-                    ("amiento", ""), ("imientos", ""), ("imiento", ""),
-                    ("aciones", ""), ("adores", ""), ("amente", ""),
-                    ("idades", ""), ("mente", ""), ("ables", ""),
-                    ("ibles", ""), ("ación", ""), ("ador", ""),
-                    ("ante", ""), ("ando", ""), ("endo", ""),
-                    ("ido", ""), ("ido", ""), ("ar", ""), ("er", ""),
-                    ("ir", ""), ("as", ""), ("es", ""), ("os", ""),
+                    ("amiento", ""),
+                    ("imientos", ""),
+                    ("imiento", ""),
+                    ("aciones", ""),
+                    ("adores", ""),
+                    ("amente", ""),
+                    ("idades", ""),
+                    ("mente", ""),
+                    ("ables", ""),
+                    ("ibles", ""),
+                    ("ación", ""),
+                    ("ador", ""),
+                    ("ante", ""),
+                    ("ando", ""),
+                    ("endo", ""),
+                    ("ido", ""),
+                    ("ido", ""),
+                    ("ar", ""),
+                    ("er", ""),
+                    ("ir", ""),
+                    ("as", ""),
+                    ("es", ""),
+                    ("os", ""),
                 ],
                 min_stem_length: 3,
             },
             Language::French => Self {
                 suffixes: vec![
-                    ("issements", ""), ("issement", ""), ("atrices", ""),
-                    ("ateurs", ""), ("ations", ""), ("logies", ""),
-                    ("usion", "u"), ("ution", "u"), ("ences", ""),
-                    ("ances", ""), ("ments", ""), ("ement", ""),
-                    ("euses", ""), ("ables", ""), ("istes", ""),
-                    ("ation", ""), ("ique", ""), ("isme", ""),
-                    ("able", ""), ("iste", ""), ("ment", ""),
-                    ("ence", ""), ("ance", ""), ("euse", ""),
-                    ("eux", ""), ("ant", ""), ("ent", ""),
+                    ("issements", ""),
+                    ("issement", ""),
+                    ("atrices", ""),
+                    ("ateurs", ""),
+                    ("ations", ""),
+                    ("logies", ""),
+                    ("usion", "u"),
+                    ("ution", "u"),
+                    ("ences", ""),
+                    ("ances", ""),
+                    ("ments", ""),
+                    ("ement", ""),
+                    ("euses", ""),
+                    ("ables", ""),
+                    ("istes", ""),
+                    ("ation", ""),
+                    ("ique", ""),
+                    ("isme", ""),
+                    ("able", ""),
+                    ("iste", ""),
+                    ("ment", ""),
+                    ("ence", ""),
+                    ("ance", ""),
+                    ("euse", ""),
+                    ("eux", ""),
+                    ("ant", ""),
+                    ("ent", ""),
                     ("e", ""),
                 ],
                 min_stem_length: 3,
             },
             Language::German => Self {
                 suffixes: vec![
-                    ("ungen", ""), ("heit", ""), ("keit", ""),
-                    ("lich", ""), ("isch", ""), ("ung", ""),
-                    ("ig", ""), ("ik", ""), ("en", ""), ("er", ""),
-                    ("em", ""), ("es", ""), ("e", ""), ("s", ""),
+                    ("ungen", ""),
+                    ("heit", ""),
+                    ("keit", ""),
+                    ("lich", ""),
+                    ("isch", ""),
+                    ("ung", ""),
+                    ("ig", ""),
+                    ("ik", ""),
+                    ("en", ""),
+                    ("er", ""),
+                    ("em", ""),
+                    ("es", ""),
+                    ("e", ""),
+                    ("s", ""),
                 ],
                 min_stem_length: 3,
             },
             _ => Self {
-                suffixes: vec![
-                    ("ing", ""), ("ed", ""), ("es", ""), ("s", ""),
-                ],
+                suffixes: vec![("ing", ""), ("ed", ""), ("es", ""), ("s", "")],
                 min_stem_length: 3,
             },
         }
@@ -406,13 +495,13 @@ impl MultiLangAnalyzer {
                         &text[start..start + c.len_utf8()]
                     })
                     .collect()
-            }
+            },
             _ => {
                 // Word-based tokenization for most languages
                 text.split(|c: char| !c.is_alphanumeric() && c != '\'')
                     .filter(|s| !s.is_empty())
                     .collect()
-            }
+            },
         }
     }
 
@@ -521,13 +610,22 @@ impl AutoLangAnalyzer {
 
         // Check common words for European languages
         let common_words: HashMap<&str, Language> = [
-            ("the", Language::English), ("and", Language::English),
-            ("der", Language::German), ("und", Language::German),
-            ("le", Language::French), ("et", Language::French),
-            ("el", Language::Spanish), ("y", Language::Spanish),
-            ("il", Language::Italian), ("che", Language::Italian),
-            ("het", Language::Dutch), ("en", Language::Dutch),
-        ].iter().cloned().collect();
+            ("the", Language::English),
+            ("and", Language::English),
+            ("der", Language::German),
+            ("und", Language::German),
+            ("le", Language::French),
+            ("et", Language::French),
+            ("el", Language::Spanish),
+            ("y", Language::Spanish),
+            ("il", Language::Italian),
+            ("che", Language::Italian),
+            ("het", Language::Dutch),
+            ("en", Language::Dutch),
+        ]
+        .iter()
+        .cloned()
+        .collect();
 
         for word in text_lower.split_whitespace() {
             if let Some(&lang) = common_words.get(word) {
diff --git a/src/multimodal.rs b/src/multimodal.rs
index 934c76a..a872ba8 100644
--- a/src/multimodal.rs
+++ b/src/multimodal.rs
@@ -56,7 +56,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -501,7 +501,7 @@ impl MultiModalIndex {
                 }
 
                 Ok(fused)
-            }
+            },
 
             MultiModalFusion::WeightedAverage(weights) => {
                 let embeddings: Vec<&Vec<f32>> = query_embeddings.values().collect();
@@ -515,7 +515,7 @@ impl MultiModalIndex {
                 }
 
                 Ok(fused)
-            }
+            },
 
             MultiModalFusion::Concatenate => {
                 // Concatenate all embeddings
@@ -524,7 +524,7 @@ impl MultiModalIndex {
                     fused.extend_from_slice(embedding);
                 }
                 Ok(fused)
-            }
+            },
 
             MultiModalFusion::Max => {
                 let embeddings: Vec<&Vec<f32>> = query_embeddings.values().collect();
@@ -538,12 +538,12 @@ impl MultiModalIndex {
                 }
 
                 Ok(fused)
-            }
+            },
 
             MultiModalFusion::LateFusion { .. } => {
                 // Should not reach here (handled separately)
                 Err(anyhow!("Late fusion not applicable in early fusion search"))
-            }
+            },
         }
     }
 
diff --git a/src/multimodal_search.rs b/src/multimodal_search.rs
index fd86fd1..1adf40d 100644
--- a/src/multimodal_search.rs
+++ b/src/multimodal_search.rs
@@ -296,7 +296,9 @@ impl Embedder for MockEmbedder {
 
         for (i, chunk) in bytes.chunks(4).enumerate() {
             let idx = i % self.dimension;
-            let val: u32 = chunk.iter().fold(0u32, |acc, &b| acc.wrapping_add(b as u32));
+            let val: u32 = chunk
+                .iter()
+                .fold(0u32, |acc, &b| acc.wrapping_add(b as u32));
             embedding[idx] = ((val as f32) / 255.0 - 0.5) * 2.0;
         }
 
@@ -362,15 +364,17 @@ impl MultimodalIndex {
 
         // Add to documents
         {
-            let mut docs = self.documents.write()
-                .map_err(|_| VecStoreError::LockError("failed to acquire documents write lock".into()))?;
+            let mut docs = self.documents.write().map_err(|_| {
+                VecStoreError::LockError("failed to acquire documents write lock".into())
+            })?;
             docs.insert(id.clone(), doc);
         }
 
         // Add to modality index
         {
-            let mut indexes = self.modality_indexes.write()
-                .map_err(|_| VecStoreError::LockError("failed to acquire modality_indexes write lock".into()))?;
+            let mut indexes = self.modality_indexes.write().map_err(|_| {
+                VecStoreError::LockError("failed to acquire modality_indexes write lock".into())
+            })?;
             indexes.entry(modality).or_insert_with(Vec::new).push(id);
         }
 
@@ -378,7 +382,12 @@ impl MultimodalIndex {
     }
 
     /// Insert text document
-    pub fn insert_text(&self, id: &str, text: &str, metadata: HashMap<String, serde_json::Value>) -> Result<()> {
+    pub fn insert_text(
+        &self,
+        id: &str,
+        text: &str,
+        metadata: HashMap<String, serde_json::Value>,
+    ) -> Result<()> {
         let embedding = self.embedder.embed_text(text)?;
 
         let doc = MultimodalDocument {
@@ -396,7 +405,13 @@ impl MultimodalIndex {
     }
 
     /// Insert image document
-    pub fn insert_image(&self, id: &str, image_ref: &str, caption: Option<&str>, metadata: HashMap<String, serde_json::Value>) -> Result<()> {
+    pub fn insert_image(
+        &self,
+        id: &str,
+        image_ref: &str,
+        caption: Option<&str>,
+        metadata: HashMap<String, serde_json::Value>,
+    ) -> Result<()> {
         let embedding = self.embedder.embed_image(image_ref)?;
 
         let mut aux = HashMap::new();
@@ -432,19 +447,30 @@ impl MultimodalIndex {
             return Err(VecStoreError::InvalidInput("No query provided".to_string()));
         };
 
-        let docs = self.documents.read()
-            .map_err(|_| VecStoreError::LockError("failed to acquire documents read lock".into()))?;
-        let indexes = self.modality_indexes.read()
-            .map_err(|_| VecStoreError::LockError("failed to acquire modality_indexes read lock".into()))?;
+        let docs = self.documents.read().map_err(|_| {
+            VecStoreError::LockError("failed to acquire documents read lock".into())
+        })?;
+        let indexes = self.modality_indexes.read().map_err(|_| {
+            VecStoreError::LockError("failed to acquire modality_indexes read lock".into())
+        })?;
 
         // Determine which documents to search
         let candidate_ids: Vec<&String> = if let Some(target) = &query.target_modality {
             // Search only target modality
-            indexes.get(target).map(|ids| ids.iter().collect()).unwrap_or_default()
+            indexes
+                .get(target)
+                .map(|ids| ids.iter().collect())
+                .unwrap_or_default()
         } else if let Some(filter) = &query.modality_filter {
             // Search filtered modalities
-            filter.iter()
-                .flat_map(|m| indexes.get(m).map(|ids| ids.iter()).unwrap_or_else(|| [].iter()))
+            filter
+                .iter()
+                .flat_map(|m| {
+                    indexes
+                        .get(m)
+                        .map(|ids| ids.iter())
+                        .unwrap_or_else(|| [].iter())
+                })
                 .collect()
         } else {
             // Search all
@@ -474,16 +500,17 @@ impl MultimodalIndex {
                     let final_score = if let Some(ref cs) = cross_scores {
                         match &self.config.fusion_strategy {
                             FusionStrategy::WeightedSum => {
-                                let aux_avg: f32 = cs.values().sum::<f32>() / cs.len().max(1) as f32;
+                                let aux_avg: f32 =
+                                    cs.values().sum::<f32>() / cs.len().max(1) as f32;
                                 score * 0.7 + aux_avg * 0.3
-                            }
+                            },
                             FusionStrategy::MaxScore => {
                                 cs.values().fold(score, |max, &s| max.max(s))
-                            }
+                            },
                             FusionStrategy::Average => {
                                 let sum: f32 = cs.values().sum::<f32>() + score;
                                 sum / (cs.len() + 1) as f32
-                            }
+                            },
                             FusionStrategy::LateFusion { weights } => {
                                 let mut weighted_sum = score;
                                 for (name, &s) in cs {
@@ -491,16 +518,17 @@ impl MultimodalIndex {
                                     weighted_sum += s * w;
                                 }
                                 weighted_sum
-                            }
+                            },
                         }
                     } else {
                         score
                     };
 
                     // Apply metadata filters
-                    let passes_filters = query.filters.iter().all(|(key, value)| {
-                        doc.metadata.get(key) == Some(value)
-                    });
+                    let passes_filters = query
+                        .filters
+                        .iter()
+                        .all(|(key, value)| doc.metadata.get(key) == Some(value));
 
                     if passes_filters {
                         Some(MultimodalResult {
@@ -553,16 +581,22 @@ impl MultimodalIndex {
 
     /// Get document by ID
     pub fn get(&self, id: &str) -> Option<MultimodalDocument> {
-        let Ok(docs) = self.documents.read() else { return None; };
+        let Ok(docs) = self.documents.read() else {
+            return None;
+        };
         docs.get(id).cloned()
     }
 
     /// Delete document
     pub fn delete(&self, id: &str) -> bool {
-        let Ok(mut docs) = self.documents.write() else { return false; };
+        let Ok(mut docs) = self.documents.write() else {
+            return false;
+        };
 
         if let Some(doc) = docs.remove(id) {
-            let Ok(mut indexes) = self.modality_indexes.write() else { return false; };
+            let Ok(mut indexes) = self.modality_indexes.write() else {
+                return false;
+            };
             if let Some(ids) = indexes.get_mut(&doc.modality) {
                 ids.retain(|x| x != id);
             }
@@ -643,10 +677,19 @@ mod tests {
         let index = MultimodalIndex::new(config);
 
         // Insert text
-        index.insert_text("txt1", "A beautiful sunset over the ocean", HashMap::new()).unwrap();
+        index
+            .insert_text("txt1", "A beautiful sunset over the ocean", HashMap::new())
+            .unwrap();
 
         // Insert image
-        index.insert_image("img1", "/path/to/sunset.jpg", Some("sunset photo"), HashMap::new()).unwrap();
+        index
+            .insert_image(
+                "img1",
+                "/path/to/sunset.jpg",
+                Some("sunset photo"),
+                HashMap::new(),
+            )
+            .unwrap();
 
         // Search
         let results = index.search(MultimodalQuery::text("sunset")).unwrap();
@@ -660,12 +703,14 @@ mod tests {
 
         // Insert images
         for i in 0..5 {
-            index.insert_image(
-                &format!("img_{}", i),
-                &format!("/images/{}.jpg", i),
-                Some(&format!("Photo number {}", i)),
-                HashMap::new(),
-            ).unwrap();
+            index
+                .insert_image(
+                    &format!("img_{}", i),
+                    &format!("/images/{}.jpg", i),
+                    Some(&format!("Photo number {}", i)),
+                    HashMap::new(),
+                )
+                .unwrap();
         }
 
         // Text to image search
@@ -682,14 +727,17 @@ mod tests {
         let config = MultimodalConfig::default();
         let index = MultimodalIndex::new(config);
 
-        index.insert_text("txt1", "Hello world", HashMap::new()).unwrap();
-        index.insert_image("img1", "/img.jpg", None, HashMap::new()).unwrap();
+        index
+            .insert_text("txt1", "Hello world", HashMap::new())
+            .unwrap();
+        index
+            .insert_image("img1", "/img.jpg", None, HashMap::new())
+            .unwrap();
 
         // Filter to only text
-        let results = index.search(
-            MultimodalQuery::text("hello")
-                .with_modality_filter(vec![Modality::Text])
-        ).unwrap();
+        let results = index
+            .search(MultimodalQuery::text("hello").with_modality_filter(vec![Modality::Text]))
+            .unwrap();
 
         assert!(results.iter().all(|r| r.modality == Modality::Text));
     }
@@ -699,9 +747,15 @@ mod tests {
         let config = MultimodalConfig::default();
         let index = MultimodalIndex::new(config);
 
-        index.insert_text("txt1", "Text document", HashMap::new()).unwrap();
-        index.insert_text("txt2", "Another text", HashMap::new()).unwrap();
-        index.insert_image("img1", "/img.jpg", None, HashMap::new()).unwrap();
+        index
+            .insert_text("txt1", "Text document", HashMap::new())
+            .unwrap();
+        index
+            .insert_text("txt2", "Another text", HashMap::new())
+            .unwrap();
+        index
+            .insert_image("img1", "/img.jpg", None, HashMap::new())
+            .unwrap();
 
         let stats = index.stats();
         assert_eq!(stats.total_documents, 3);
diff --git a/src/namespace.rs b/src/namespace.rs
index 526b3ba..1fa749c 100644
--- a/src/namespace.rs
+++ b/src/namespace.rs
@@ -3,7 +3,7 @@
 //! Provides namespace isolation, per-namespace quotas, and resource management
 //! for SaaS deployments.
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -177,33 +177,36 @@ impl ResourceUsage {
     pub fn check_quotas(&self, quotas: &NamespaceQuotas) -> Result<()> {
         // Check vector count
         if let Some(max_vectors) = quotas.max_vectors
-            && self.vector_count >= max_vectors {
-                return Err(anyhow!(
-                    "Vector quota exceeded: {} / {} vectors",
-                    self.vector_count,
-                    max_vectors
-                ));
-            }
+            && self.vector_count >= max_vectors
+        {
+            return Err(anyhow!(
+                "Vector quota exceeded: {} / {} vectors",
+                self.vector_count,
+                max_vectors
+            ));
+        }
 
         // Check storage
         if let Some(max_storage) = quotas.max_storage_bytes
-            && self.storage_bytes >= max_storage {
-                return Err(anyhow!(
-                    "Storage quota exceeded: {} / {} bytes",
-                    self.storage_bytes,
-                    max_storage
-                ));
-            }
+            && self.storage_bytes >= max_storage
+        {
+            return Err(anyhow!(
+                "Storage quota exceeded: {} / {} bytes",
+                self.storage_bytes,
+                max_storage
+            ));
+        }
 
         // Check concurrent queries
         if let Some(max_concurrent) = quotas.max_concurrent_queries
-            && self.active_queries >= max_concurrent {
-                return Err(anyhow!(
-                    "Concurrent query limit exceeded: {} / {}",
-                    self.active_queries,
-                    max_concurrent
-                ));
-            }
+            && self.active_queries >= max_concurrent
+        {
+            return Err(anyhow!(
+                "Concurrent query limit exceeded: {} / {}",
+                self.active_queries,
+                max_concurrent
+            ));
+        }
 
         Ok(())
     }
@@ -223,9 +226,10 @@ impl ResourceUsage {
 
         // Check rate limit
         if let Some(max_rps) = quotas.max_requests_per_second
-            && self.requests_current_window as f64 >= max_rps {
-                return Err(anyhow!("Rate limit exceeded: {} requests/second", max_rps));
-            }
+            && self.requests_current_window as f64 >= max_rps
+        {
+            return Err(anyhow!("Rate limit exceeded: {} requests/second", max_rps));
+        }
 
         self.requests_current_window += 1;
         self.total_requests += 1;
@@ -277,24 +281,26 @@ impl Namespace {
 
         // Check if adding 'count' vectors would exceed quota
         if let Some(max_vectors) = self.quotas.max_vectors
-            && self.usage.vector_count + count > max_vectors {
-                return Err(anyhow!(
-                    "Upsert would exceed vector quota: {} + {} > {}",
-                    self.usage.vector_count,
-                    count,
-                    max_vectors
-                ));
-            }
+            && self.usage.vector_count + count > max_vectors
+        {
+            return Err(anyhow!(
+                "Upsert would exceed vector quota: {} + {} > {}",
+                self.usage.vector_count,
+                count,
+                max_vectors
+            ));
+        }
 
         // Check batch size
         if let Some(max_batch) = self.quotas.max_batch_size
-            && count > max_batch {
-                return Err(anyhow!(
-                    "Batch size exceeds limit: {} > {}",
-                    count,
-                    max_batch
-                ));
-            }
+            && count > max_batch
+        {
+            return Err(anyhow!(
+                "Batch size exceeds limit: {} > {}",
+                count,
+                max_batch
+            ));
+        }
 
         Ok(())
     }
@@ -305,15 +311,15 @@ impl Namespace {
         match self.status {
             NamespaceStatus::PendingDeletion => {
                 return Err(anyhow!("Namespace is pending deletion"));
-            }
+            },
             NamespaceStatus::Suspended => {
                 return Err(anyhow!(
                     "Namespace is suspended. Contact administrator to reactivate."
                 ));
-            }
+            },
             NamespaceStatus::Active | NamespaceStatus::ReadOnly => {
                 // OK to query
-            }
+            },
         }
 
         // Check concurrent query limit
@@ -321,13 +327,14 @@ impl Namespace {
 
         // Check result limit
         if let Some(max_results) = self.quotas.max_results_per_query
-            && k > max_results {
-                return Err(anyhow!(
-                    "Query limit exceeds maximum: {} > {}",
-                    k,
-                    max_results
-                ));
-            }
+            && k > max_results
+        {
+            return Err(anyhow!(
+                "Query limit exceeds maximum: {} > {}",
+                k,
+                max_results
+            ));
+        }
 
         Ok(())
     }
diff --git a/src/namespace_manager.rs b/src/namespace_manager.rs
index 52bf7dd..60b3425 100644
--- a/src/namespace_manager.rs
+++ b/src/namespace_manager.rs
@@ -5,7 +5,7 @@
 
 use crate::namespace::{Namespace, NamespaceId, NamespaceQuotas, NamespaceStatus};
 use crate::store::{Metadata, Neighbor, Query, VecStore};
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, PoisonError, RwLock};
diff --git a/src/neural_ranker.rs b/src/neural_ranker.rs
index e145993..98cd08a 100644
--- a/src/neural_ranker.rs
+++ b/src/neural_ranker.rs
@@ -408,10 +408,14 @@ impl NeuralRanker {
             max_length: self.config.max_seq_length,
         };
 
-        *self.model.write()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire model write lock".into()))? = Some(model);
-        *self.tokenizer.write()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire tokenizer write lock".into()))? = Some(tokenizer);
+        *self
+            .model
+            .write()
+            .map_err(|_| VecStoreError::LockError("Failed to acquire model write lock".into()))? =
+            Some(model);
+        *self.tokenizer.write().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire tokenizer write lock".into())
+        })? = Some(tokenizer);
 
         Ok(())
     }
@@ -499,10 +503,13 @@ impl NeuralRanker {
     pub fn rerank(&self, query: &str, candidates: Vec<RerankCandidate>) -> Result<RerankResponse> {
         let start = Instant::now();
         self.stats.total_reranks.fetch_add(1, Ordering::Relaxed);
-        self.stats.total_candidates.fetch_add(candidates.len() as u64, Ordering::Relaxed);
+        self.stats
+            .total_candidates
+            .fetch_add(candidates.len() as u64, Ordering::Relaxed);
 
         // Limit candidates
-        let top_candidates: Vec<_> = candidates.into_iter()
+        let top_candidates: Vec<_> = candidates
+            .into_iter()
             .take(self.config.rerank_top_k)
             .collect();
 
@@ -517,8 +524,9 @@ impl NeuralRanker {
 
             // Check cache
             let neural_score = {
-                let cache = self.cache.read()
-                    .map_err(|_| VecStoreError::LockError("Failed to acquire cache read lock".into()))?;
+                let cache = self.cache.read().map_err(|_| {
+                    VecStoreError::LockError("Failed to acquire cache read lock".into())
+                })?;
                 if let Some(entry) = cache.entries.get(&cache_key) {
                     cache_hit = true;
                     self.stats.cache_hits.fetch_add(1, Ordering::Relaxed);
@@ -531,14 +539,18 @@ impl NeuralRanker {
                     let score = self.compute_score(query, &candidate.text)?;
 
                     // Cache result
-                    let mut cache = self.cache.write()
-                        .map_err(|_| VecStoreError::LockError("Failed to acquire cache write lock".into()))?;
+                    let mut cache = self.cache.write().map_err(|_| {
+                        VecStoreError::LockError("Failed to acquire cache write lock".into())
+                    })?;
                     if cache.entries.len() < cache.max_size {
-                        cache.entries.insert(cache_key, CacheEntry {
-                            embedding: vec![score],
-                            created_at: Instant::now(),
-                            access_count: 1,
-                        });
+                        cache.entries.insert(
+                            cache_key,
+                            CacheEntry {
+                                embedding: vec![score],
+                                created_at: Instant::now(),
+                                access_count: 1,
+                            },
+                        );
                     }
 
                     score
@@ -624,7 +636,9 @@ impl NeuralRanker {
 
         // Use token ID and position to seed the embedding
         // This creates consistent, position-aware embeddings
-        let mut seed = (token_id as u64).wrapping_mul(31).wrapping_add(position as u64);
+        let mut seed = (token_id as u64)
+            .wrapping_mul(31)
+            .wrapping_add(position as u64);
 
         for (i, emb_val) in embedding.iter_mut().enumerate().take(dim) {
             // LCG for deterministic pseudo-random values
@@ -738,14 +752,22 @@ impl NeuralRanker {
 
     /// Tokenize text
     fn tokenize(&self, text: &str) -> Result<Vec<u32>> {
-        let tokenizer = self.tokenizer.read()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire tokenizer read lock".into()))?;
-        let tokenizer = tokenizer.as_ref()
+        let tokenizer = self.tokenizer.read().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire tokenizer read lock".into())
+        })?;
+        let tokenizer = tokenizer
+            .as_ref()
             .ok_or(VecStoreError::IndexNotInitialized)?;
 
         let words: Vec<&str> = text.split_whitespace().collect();
-        let tokens: Vec<u32> = words.iter()
-            .map(|w| *tokenizer.vocab.get(*w).unwrap_or(&tokenizer.special_tokens.unk_token))
+        let tokens: Vec<u32> = words
+            .iter()
+            .map(|w| {
+                *tokenizer
+                    .vocab
+                    .get(*w)
+                    .unwrap_or(&tokenizer.special_tokens.unk_token)
+            })
             .take(tokenizer.max_length)
             .collect();
 
@@ -778,7 +800,9 @@ impl NeuralRanker {
 
     /// Update running average latency
     fn update_latency(&self, latency_ms: f64) {
-        let Ok(mut avg) = self.stats.avg_latency_ms.write() else { return; };
+        let Ok(mut avg) = self.stats.avg_latency_ms.write() else {
+            return;
+        };
         let count = self.stats.total_reranks.load(Ordering::Relaxed) as f64;
         *avg = (*avg * (count - 1.0) + latency_ms) / count;
     }
@@ -793,7 +817,11 @@ impl NeuralRanker {
             cache_hit_rate: {
                 let hits = self.stats.cache_hits.load(Ordering::Relaxed) as f64;
                 let misses = self.stats.cache_misses.load(Ordering::Relaxed) as f64;
-                if hits + misses > 0.0 { hits / (hits + misses) } else { 0.0 }
+                if hits + misses > 0.0 {
+                    hits / (hits + misses)
+                } else {
+                    0.0
+                }
             },
             avg_latency_ms: self.stats.avg_latency_ms.read().map(|g| *g).unwrap_or(0.0),
             gpu_inferences: self.stats.gpu_inferences.load(Ordering::Relaxed),
@@ -803,7 +831,9 @@ impl NeuralRanker {
 
     /// Clear embedding cache
     pub fn clear_cache(&self) {
-        let Ok(mut cache) = self.cache.write() else { return; };
+        let Ok(mut cache) = self.cache.write() else {
+            return;
+        };
         cache.entries.clear();
         cache.hits = 0;
         cache.misses = 0;
@@ -877,9 +907,7 @@ impl CrossEncoder {
 
     /// Batch score multiple pairs
     pub fn batch_score(&self, pairs: &[(String, String)]) -> Result<Vec<f32>> {
-        pairs.iter()
-            .map(|(q, d)| self.score(q, d))
-            .collect()
+        pairs.iter().map(|(q, d)| self.score(q, d)).collect()
     }
 }
 
@@ -896,24 +924,28 @@ impl LateInteractionModel {
 
     /// Encode a query
     pub fn encode_query(&self, query: &str) -> Result<Vec<Vec<f32>>> {
-        let tokens: Vec<&str> = query.split_whitespace()
+        let tokens: Vec<&str> = query
+            .split_whitespace()
             .take(self.config.query_max_tokens)
             .collect();
 
         // Generate embeddings per token
-        Ok(tokens.iter()
+        Ok(tokens
+            .iter()
             .map(|_| vec![0.0; self.config.embedding_dim])
             .collect())
     }
 
     /// Encode a document
     pub fn encode_document(&self, doc: &str) -> Result<Vec<Vec<f32>>> {
-        let tokens: Vec<&str> = doc.split_whitespace()
+        let tokens: Vec<&str> = doc
+            .split_whitespace()
             .take(self.config.doc_max_tokens)
             .collect();
 
         // Generate embeddings per token
-        let embeddings: Vec<Vec<f32>> = tokens.iter()
+        let embeddings: Vec<Vec<f32>> = tokens
+            .iter()
             .map(|_| vec![0.0; self.config.embedding_dim])
             .collect();
 
@@ -944,7 +976,8 @@ impl LateInteractionModel {
     fn max_sim(&self, query: &[Vec<f32>], doc: &[Vec<f32>]) -> f32 {
         let mut total = 0.0;
         for q in query {
-            let max = doc.iter()
+            let max = doc
+                .iter()
                 .map(|d| cosine_similarity(q, d))
                 .fold(f32::MIN, f32::max);
             total += max;
@@ -957,21 +990,19 @@ impl LateInteractionModel {
     }
 
     fn avg_max(&self, query: &[Vec<f32>], doc: &[Vec<f32>]) -> f32 {
-        if query.is_empty() { return 0.0; }
+        if query.is_empty() {
+            return 0.0;
+        }
         self.max_sim(query, doc) / query.len() as f32
     }
 
     fn soft_max(&self, query: &[Vec<f32>], doc: &[Vec<f32>]) -> f32 {
         let mut total = 0.0;
         for q in query {
-            let sims: Vec<f32> = doc.iter()
-                .map(|d| cosine_similarity(q, d))
-                .collect();
+            let sims: Vec<f32> = doc.iter().map(|d| cosine_similarity(q, d)).collect();
             let max = sims.iter().fold(f32::MIN, |a, &b| a.max(b));
             let exp_sum: f32 = sims.iter().map(|&s| (s - max).exp()).sum();
-            let softmax_weighted: f32 = sims.iter()
-                .map(|&s| s * (s - max).exp() / exp_sum)
-                .sum();
+            let softmax_weighted: f32 = sims.iter().map(|&s| s * (s - max).exp() / exp_sum).sum();
             total += softmax_weighted;
         }
         total
@@ -979,17 +1010,21 @@ impl LateInteractionModel {
 
     /// Index document embeddings
     pub fn index_document(&self, doc_id: &str, embeddings: Vec<Vec<f32>>) {
-        let Ok(mut doc_emb) = self.doc_embeddings.write() else { return; };
+        let Ok(mut doc_emb) = self.doc_embeddings.write() else {
+            return;
+        };
         doc_emb.insert(doc_id.to_string(), embeddings);
     }
 
     /// Retrieve and score against indexed documents
     pub fn retrieve(&self, query: &str, top_k: usize) -> Result<Vec<(String, f32)>> {
         let query_embeddings = self.encode_query(query)?;
-        let docs = self.doc_embeddings.read()
-            .map_err(|_| VecStoreError::LockError("Failed to acquire doc_embeddings read lock".into()))?;
+        let docs = self.doc_embeddings.read().map_err(|_| {
+            VecStoreError::LockError("Failed to acquire doc_embeddings read lock".into())
+        })?;
 
-        let mut scores: Vec<(String, f32)> = docs.iter()
+        let mut scores: Vec<(String, f32)> = docs
+            .iter()
             .map(|(id, emb)| (id.clone(), self.score(&query_embeddings, emb)))
             .collect();
 
@@ -1013,7 +1048,9 @@ impl LearnedSparseModel {
     /// Encode text to sparse representation
     pub fn encode(&self, text: &str) -> Result<SparseRepresentation> {
         let tokens: Vec<&str> = text.split_whitespace().collect();
-        let vocab = self.vocab.read()
+        let vocab = self
+            .vocab
+            .read()
             .map_err(|_| VecStoreError::LockError("Failed to acquire vocab read lock".into()))?;
 
         let mut term_ids = Vec::new();
@@ -1132,7 +1169,9 @@ impl EnsembleRanker {
 
     /// Score using ensemble
     pub fn score(&self, query: &str, document: &str) -> Result<f32> {
-        let scores: Vec<f32> = self.rankers.iter()
+        let scores: Vec<f32> = self
+            .rankers
+            .iter()
             .filter_map(|(r, _)| r.score(query, document).ok())
             .collect();
 
@@ -1143,34 +1182,30 @@ impl EnsembleRanker {
         match &self.config.combination {
             CombinationMethod::WeightedSum => {
                 let total_weight: f32 = self.rankers.iter().map(|(_, w)| w).sum();
-                let weighted_sum: f32 = scores.iter()
+                let weighted_sum: f32 = scores
+                    .iter()
                     .zip(self.rankers.iter())
                     .map(|(s, (_, w))| s * w)
                     .sum();
                 Ok(weighted_sum / total_weight)
-            }
-            CombinationMethod::Max => {
-                Ok(scores.iter().fold(f32::MIN, |a, &b| a.max(b)))
-            }
-            CombinationMethod::Min => {
-                Ok(scores.iter().fold(f32::MAX, |a, &b| a.min(b)))
-            }
-            CombinationMethod::Average => {
-                Ok(scores.iter().sum::<f32>() / scores.len() as f32)
-            }
+            },
+            CombinationMethod::Max => Ok(scores.iter().fold(f32::MIN, |a, &b| a.max(b))),
+            CombinationMethod::Min => Ok(scores.iter().fold(f32::MAX, |a, &b| a.min(b))),
+            CombinationMethod::Average => Ok(scores.iter().sum::<f32>() / scores.len() as f32),
             CombinationMethod::RRF(k) => {
                 // Reciprocal rank fusion
-                let rrf: f32 = scores.iter()
+                let rrf: f32 = scores
+                    .iter()
                     .enumerate()
                     .map(|(rank, _)| 1.0 / (k + rank as f32 + 1.0))
                     .sum();
                 Ok(rrf)
-            }
+            },
             CombinationMethod::CombMNZ => {
                 let non_zero = scores.iter().filter(|&&s| s > 0.0).count() as f32;
                 let sum: f32 = scores.iter().sum();
                 Ok(sum * non_zero)
-            }
+            },
         }
     }
 }
diff --git a/src/object_storage.rs b/src/object_storage.rs
index dd5e5a5..95f8adc 100644
--- a/src/object_storage.rs
+++ b/src/object_storage.rs
@@ -50,7 +50,7 @@
 //! let results = store.search(&query, 10).await?;
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, VecDeque};
 use std::path::PathBuf;
@@ -399,14 +399,11 @@ impl VectorChunk {
 
     /// Get vector by ID
     pub fn get(&self, id: &str) -> Option<Vec<f32>> {
-        self.vector_ids
-            .iter()
-            .position(|vid| vid == id)
-            .map(|idx| {
-                let start = idx * self.dimension;
-                let end = start + self.dimension;
-                self.vectors[start..end].to_vec()
-            })
+        self.vector_ids.iter().position(|vid| vid == id).map(|idx| {
+            let start = idx * self.dimension;
+            let end = start + self.dimension;
+            self.vectors[start..end].to_vec()
+        })
     }
 
     /// Serialize chunk
@@ -421,8 +418,8 @@ impl VectorChunk {
 
     /// Compress chunk data
     pub fn compress(&self, level: u32) -> Result<Vec<u8>> {
-        use flate2::write::GzEncoder;
         use flate2::Compression;
+        use flate2::write::GzEncoder;
         use std::io::Write;
 
         let serialized = self.serialize()?;
@@ -761,9 +758,7 @@ impl TieredStore {
             let to_demote: Vec<String> = {
                 let mut lru = self.hot_lru.write().await;
                 let demote_count = (hot_bytes - hot_capacity_bytes) / (self.dimension * 4) + 1;
-                (0..demote_count)
-                    .filter_map(|_| lru.pop_front())
-                    .collect()
+                (0..demote_count).filter_map(|_| lru.pop_front()).collect()
             };
 
             // Demote vectors to warm tier
@@ -823,9 +818,7 @@ impl TieredStore {
 
         let chunks_to_flush: Vec<(String, VectorChunk)> = {
             let warm = self.warm_chunks.read().await;
-            warm.iter()
-                .map(|(k, v)| (k.clone(), v.clone()))
-                .collect()
+            warm.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
         };
 
         for (chunk_id, chunk) in chunks_to_flush {
diff --git a/src/object_store.rs b/src/object_store.rs
index d14b446..45b734f 100644
--- a/src/object_store.rs
+++ b/src/object_store.rs
@@ -53,15 +53,9 @@ pub enum StorageProvider {
         region: String,
     },
     /// Google Cloud Storage
-    GCS {
-        bucket: String,
-        prefix: String,
-    },
+    GCS { bucket: String, prefix: String },
     /// Azure Blob Storage
-    AzureBlob {
-        container: String,
-        prefix: String,
-    },
+    AzureBlob { container: String, prefix: String },
     /// MinIO (S3-compatible)
     MinIO {
         endpoint: String,
@@ -69,9 +63,7 @@ pub enum StorageProvider {
         prefix: String,
     },
     /// Local filesystem (for testing)
-    Local {
-        path: PathBuf,
-    },
+    Local { path: PathBuf },
 }
 
 /// Cache tier configuration
@@ -95,7 +87,10 @@ pub enum CacheStorageType {
     /// SSD-backed cache
     SSD { path: PathBuf },
     /// Hybrid memory + SSD
-    Hybrid { ssd_path: PathBuf, memory_ratio: f32 },
+    Hybrid {
+        ssd_path: PathBuf,
+        memory_ratio: f32,
+    },
 }
 
 /// Object store configuration
@@ -128,14 +123,12 @@ impl ObjectStoreConfig {
                 prefix: prefix.to_string(),
                 region: "us-east-1".to_string(),
             },
-            cache_tiers: vec![
-                CacheTier {
-                    name: "memory".to_string(),
-                    max_size_bytes: 1024 * 1024 * 1024, // 1GB
-                    ttl_seconds: 300,
-                    storage_type: CacheStorageType::Memory,
-                },
-            ],
+            cache_tiers: vec![CacheTier {
+                name: "memory".to_string(),
+                max_size_bytes: 1024 * 1024 * 1024, // 1GB
+                ttl_seconds: 300,
+                storage_type: CacheStorageType::Memory,
+            }],
             read_through_cache: true,
             write_through_cache: true,
             pre_warming: None,
@@ -152,14 +145,12 @@ impl ObjectStoreConfig {
                 bucket: bucket.to_string(),
                 prefix: prefix.to_string(),
             },
-            cache_tiers: vec![
-                CacheTier {
-                    name: "memory".to_string(),
-                    max_size_bytes: 1024 * 1024 * 1024,
-                    ttl_seconds: 300,
-                    storage_type: CacheStorageType::Memory,
-                },
-            ],
+            cache_tiers: vec![CacheTier {
+                name: "memory".to_string(),
+                max_size_bytes: 1024 * 1024 * 1024,
+                ttl_seconds: 300,
+                storage_type: CacheStorageType::Memory,
+            }],
             read_through_cache: true,
             write_through_cache: true,
             pre_warming: None,
@@ -362,15 +353,17 @@ impl MemoryCache {
 
     fn evict_one(&mut self) {
         // LRU eviction
-        let oldest_key = self.entries
+        let oldest_key = self
+            .entries
             .iter()
             .min_by_key(|(_, e)| e.last_access)
             .map(|(k, _)| k.clone());
 
         if let Some(key) = oldest_key
-            && let Some(entry) = self.entries.remove(&key) {
-                self.current_size = self.current_size.saturating_sub(entry.data.len() as u64);
-            }
+            && let Some(entry) = self.entries.remove(&key)
+        {
+            self.current_size = self.current_size.saturating_sub(entry.data.len() as u64);
+        }
     }
 
     fn invalidate(&mut self, key: &str) {
@@ -381,7 +374,8 @@ impl MemoryCache {
 
     fn stats(&self) -> CacheStats {
         let now = Instant::now();
-        let valid_entries: Vec<_> = self.entries
+        let valid_entries: Vec<_> = self
+            .entries
             .values()
             .filter(|e| now.duration_since(e.cached_at) < self.ttl)
             .collect();
@@ -484,13 +478,22 @@ impl AccessTracker {
     }
 
     fn most_recent(&self, n: usize) -> Vec<&str> {
-        self.recent.iter().rev().take(n).map(|s| s.as_str()).collect()
+        self.recent
+            .iter()
+            .rev()
+            .take(n)
+            .map(|s| s.as_str())
+            .collect()
     }
 
     fn most_frequent(&self, n: usize) -> Vec<(&str, u64)> {
         let mut items: Vec<_> = self.frequency.iter().collect();
         items.sort_by_key(|(_, count)| std::cmp::Reverse(*count));
-        items.into_iter().take(n).map(|(k, v)| (k.as_str(), *v)).collect()
+        items
+            .into_iter()
+            .take(n)
+            .map(|(k, v)| (k.as_str(), *v))
+            .collect()
     }
 }
 
@@ -549,7 +552,12 @@ impl ObjectStoreBackend {
     }
 
     /// Put a vector
-    pub fn put(&self, id: &str, vector: &[f32], metadata: &HashMap<String, serde_json::Value>) -> Result<()> {
+    pub fn put(
+        &self,
+        id: &str,
+        vector: &[f32],
+        metadata: &HashMap<String, serde_json::Value>,
+    ) -> Result<()> {
         let start = Instant::now();
 
         // Serialize
@@ -644,10 +652,14 @@ impl ObjectStoreBackend {
             // Update cache
             if self.config.read_through_cache {
                 let index_guard = self.metadata_index.read().map_err(|_| {
-                    VecStoreError::LockError("Failed to acquire metadata index read lock".to_string())
+                    VecStoreError::LockError(
+                        "Failed to acquire metadata index read lock".to_string(),
+                    )
                 })?;
-                let meta = index_guard.get(id).cloned().unwrap_or_else(|| {
-                    ObjectMetadata {
+                let meta = index_guard
+                    .get(id)
+                    .cloned()
+                    .unwrap_or_else(|| ObjectMetadata {
                         key: id.to_string(),
                         size_bytes: data.len() as u64,
                         created_at: unix_timestamp(),
@@ -655,12 +667,13 @@ impl ObjectStoreBackend {
                         access_count: 1,
                         compression: self.config.compression.clone(),
                         custom: HashMap::new(),
-                    }
-                });
+                    });
                 drop(index_guard);
 
                 let mut cache = self.memory_cache.write().map_err(|_| {
-                    VecStoreError::LockError("Failed to acquire memory cache write lock".to_string())
+                    VecStoreError::LockError(
+                        "Failed to acquire memory cache write lock".to_string(),
+                    )
                 })?;
                 cache.put(id.to_string(), data.clone(), meta);
             }
@@ -709,7 +722,10 @@ impl ObjectStoreBackend {
         let mut success_count = 0;
 
         for vector in vectors {
-            if self.put(&vector.id, &vector.vector, &vector.metadata).is_ok() {
+            if self
+                .put(&vector.id, &vector.vector, &vector.metadata)
+                .is_ok()
+            {
                 success_count += 1;
             }
         }
@@ -735,26 +751,42 @@ impl ObjectStoreBackend {
         let ids_to_warm: Vec<String> = match strategy {
             PreWarmStrategy::MostRecent => {
                 let tracker = self.access_tracker.read().map_err(|_| {
-                    VecStoreError::LockError("Failed to acquire access tracker read lock".to_string())
+                    VecStoreError::LockError(
+                        "Failed to acquire access tracker read lock".to_string(),
+                    )
                 })?;
-                tracker.most_recent(count).into_iter().map(|s| s.to_string()).collect()
-            }
+                tracker
+                    .most_recent(count)
+                    .into_iter()
+                    .map(|s| s.to_string())
+                    .collect()
+            },
             PreWarmStrategy::MostFrequent => {
                 let tracker = self.access_tracker.read().map_err(|_| {
-                    VecStoreError::LockError("Failed to acquire access tracker read lock".to_string())
+                    VecStoreError::LockError(
+                        "Failed to acquire access tracker read lock".to_string(),
+                    )
                 })?;
-                tracker.most_frequent(count).into_iter().map(|(s, _)| s.to_string()).collect()
-            }
+                tracker
+                    .most_frequent(count)
+                    .into_iter()
+                    .map(|(s, _)| s.to_string())
+                    .collect()
+            },
             PreWarmStrategy::Predictive => {
                 // Use frequency as a simple predictor
                 let tracker = self.access_tracker.read().map_err(|_| {
-                    VecStoreError::LockError("Failed to acquire access tracker read lock".to_string())
+                    VecStoreError::LockError(
+                        "Failed to acquire access tracker read lock".to_string(),
+                    )
                 })?;
-                tracker.most_frequent(count).into_iter().map(|(s, _)| s.to_string()).collect()
-            }
-            PreWarmStrategy::Explicit { ids } => {
-                ids.iter().take(count).cloned().collect()
-            }
+                tracker
+                    .most_frequent(count)
+                    .into_iter()
+                    .map(|(s, _)| s.to_string())
+                    .collect()
+            },
+            PreWarmStrategy::Explicit { ids } => ids.iter().take(count).cloned().collect(),
         };
 
         let mut warmed = 0;
@@ -884,8 +916,8 @@ impl ObjectStoreBackend {
     // Internal methods
 
     fn serialize(&self, vector: &StoredVector) -> Result<Vec<u8>> {
-        let json = serde_json::to_vec(vector)
-            .map_err(|e| VecStoreError::Serialization(e.to_string()))?;
+        let json =
+            serde_json::to_vec(vector).map_err(|e| VecStoreError::Serialization(e.to_string()))?;
 
         // Apply compression
         match &self.config.compression {
@@ -893,7 +925,7 @@ impl ObjectStoreBackend {
             CompressionType::Zstd { level: _ } => {
                 // Simplified - in production would use actual zstd
                 Ok(json) // Placeholder
-            }
+            },
             CompressionType::Gzip { level: _ } => Ok(json),
             CompressionType::Lz4 => Ok(json),
             CompressionType::Snappy => Ok(json),
@@ -914,55 +946,67 @@ impl ObjectStoreBackend {
         match &self.config.provider {
             StorageProvider::Local { path: _ } => {
                 let mut storage = self.local_storage.write().map_err(|_| {
-                    VecStoreError::LockError("Failed to acquire local storage write lock".to_string())
+                    VecStoreError::LockError(
+                        "Failed to acquire local storage write lock".to_string(),
+                    )
                 })?;
                 storage.insert(key.to_string(), data.to_vec());
                 Ok(())
-            }
+            },
             StorageProvider::S3 { .. } => {
                 // In production: use aws-sdk-s3
                 let mut storage = self.local_storage.write().map_err(|_| {
-                    VecStoreError::LockError("Failed to acquire local storage write lock".to_string())
+                    VecStoreError::LockError(
+                        "Failed to acquire local storage write lock".to_string(),
+                    )
                 })?;
                 storage.insert(key.to_string(), data.to_vec());
                 Ok(())
-            }
+            },
             StorageProvider::GCS { .. } => {
                 let mut storage = self.local_storage.write().map_err(|_| {
-                    VecStoreError::LockError("Failed to acquire local storage write lock".to_string())
+                    VecStoreError::LockError(
+                        "Failed to acquire local storage write lock".to_string(),
+                    )
                 })?;
                 storage.insert(key.to_string(), data.to_vec());
                 Ok(())
-            }
+            },
             StorageProvider::AzureBlob { .. } => {
                 let mut storage = self.local_storage.write().map_err(|_| {
-                    VecStoreError::LockError("Failed to acquire local storage write lock".to_string())
+                    VecStoreError::LockError(
+                        "Failed to acquire local storage write lock".to_string(),
+                    )
                 })?;
                 storage.insert(key.to_string(), data.to_vec());
                 Ok(())
-            }
+            },
             StorageProvider::MinIO { .. } => {
                 let mut storage = self.local_storage.write().map_err(|_| {
-                    VecStoreError::LockError("Failed to acquire local storage write lock".to_string())
+                    VecStoreError::LockError(
+                        "Failed to acquire local storage write lock".to_string(),
+                    )
                 })?;
                 storage.insert(key.to_string(), data.to_vec());
                 Ok(())
-            }
+            },
         }
     }
 
     fn read_from_backend(&self, key: &str) -> Result<Option<Vec<u8>>> {
         match &self.config.provider {
-            StorageProvider::Local { path: _ } |
-            StorageProvider::S3 { .. } |
-            StorageProvider::GCS { .. } |
-            StorageProvider::AzureBlob { .. } |
-            StorageProvider::MinIO { .. } => {
+            StorageProvider::Local { path: _ }
+            | StorageProvider::S3 { .. }
+            | StorageProvider::GCS { .. }
+            | StorageProvider::AzureBlob { .. }
+            | StorageProvider::MinIO { .. } => {
                 let storage = self.local_storage.read().map_err(|_| {
-                    VecStoreError::LockError("Failed to acquire local storage read lock".to_string())
+                    VecStoreError::LockError(
+                        "Failed to acquire local storage read lock".to_string(),
+                    )
                 })?;
                 Ok(storage.get(key).cloned())
-            }
+            },
         }
     }
 
@@ -1027,8 +1071,8 @@ pub struct TieringConfig {
 impl Default for TieringConfig {
     fn default() -> Self {
         Self {
-            hot_to_warm_seconds: 3600,      // 1 hour
-            warm_to_cold_seconds: 86400,    // 24 hours
+            hot_to_warm_seconds: 3600,   // 1 hour
+            warm_to_cold_seconds: 86400, // 24 hours
             hot_access_threshold: 10,
         }
     }
@@ -1059,7 +1103,12 @@ impl TieredStorageManager {
     }
 
     /// Put to appropriate tier
-    pub fn put(&self, id: &str, vector: &[f32], metadata: &HashMap<String, serde_json::Value>) -> Result<()> {
+    pub fn put(
+        &self,
+        id: &str,
+        vector: &[f32],
+        metadata: &HashMap<String, serde_json::Value>,
+    ) -> Result<()> {
         // New data goes to hot tier
         self.hot_tier.put(id, vector, metadata)?;
 
@@ -1080,19 +1129,23 @@ impl TieredStorageManager {
 
         // Try warm
         if let Some(warm) = &self.warm_tier
-            && let Some(vector) = warm.get(id)? {
-                // Promote to hot on access
-                self.hot_tier.put(&vector.id, &vector.vector, &vector.metadata)?;
-                return Ok(Some(vector));
-            }
+            && let Some(vector) = warm.get(id)?
+        {
+            // Promote to hot on access
+            self.hot_tier
+                .put(&vector.id, &vector.vector, &vector.metadata)?;
+            return Ok(Some(vector));
+        }
 
         // Try cold
         if let Some(cold) = &self.cold_tier
-            && let Some(vector) = cold.get(id)? {
-                // Promote to hot on access
-                self.hot_tier.put(&vector.id, &vector.vector, &vector.metadata)?;
-                return Ok(Some(vector));
-            }
+            && let Some(vector) = cold.get(id)?
+        {
+            // Promote to hot on access
+            self.hot_tier
+                .put(&vector.id, &vector.vector, &vector.metadata)?;
+            return Ok(Some(vector));
+        }
 
         Ok(None)
     }
@@ -1151,8 +1204,8 @@ mod tests {
 
     #[test]
     fn test_cache_behavior() {
-        let mut config = ObjectStoreConfig::local("/tmp/vecstore_cache_test")
-            .with_cache_tier(CacheTier {
+        let mut config =
+            ObjectStoreConfig::local("/tmp/vecstore_cache_test").with_cache_tier(CacheTier {
                 name: "memory".to_string(),
                 max_size_bytes: 1024 * 1024,
                 ttl_seconds: 300,
@@ -1212,7 +1265,9 @@ mod tests {
 
         // Add some data
         for i in 0..100 {
-            backend.put(&format!("vec_{}", i), &vec![0.1; 128], &HashMap::new()).unwrap();
+            backend
+                .put(&format!("vec_{}", i), &vec![0.1; 128], &HashMap::new())
+                .unwrap();
         }
 
         let cost = backend.estimate_cost();
diff --git a/src/otel.rs b/src/otel.rs
index 4ea4c64..b1e2279 100644
--- a/src/otel.rs
+++ b/src/otel.rs
@@ -27,7 +27,10 @@
 //! ```
 
 use std::collections::HashMap;
-use std::sync::{Arc, RwLock, atomic::{AtomicU64, AtomicUsize, Ordering}};
+use std::sync::{
+    Arc, RwLock,
+    atomic::{AtomicU64, AtomicUsize, Ordering},
+};
 use std::time::{Duration, Instant, UNIX_EPOCH};
 
 use serde::{Deserialize, Serialize};
@@ -119,9 +122,15 @@ impl OtelConfig {
         Self {
             service_name: "vecstore".to_string(),
             service_version: env!("CARGO_PKG_VERSION").to_string(),
-            trace_exporter: ExporterType::OtlpGrpc { endpoint: endpoint.to_string() },
-            metrics_exporter: ExporterType::OtlpGrpc { endpoint: endpoint.to_string() },
-            logs_exporter: ExporterType::OtlpGrpc { endpoint: endpoint.to_string() },
+            trace_exporter: ExporterType::OtlpGrpc {
+                endpoint: endpoint.to_string(),
+            },
+            metrics_exporter: ExporterType::OtlpGrpc {
+                endpoint: endpoint.to_string(),
+            },
+            logs_exporter: ExporterType::OtlpGrpc {
+                endpoint: endpoint.to_string(),
+            },
             sampling: SamplingStrategy::Ratio(0.1),
             resource_attributes: HashMap::new(),
             batch_config: BatchConfig::default(),
@@ -134,7 +143,9 @@ impl OtelConfig {
         Self {
             service_name: "vecstore".to_string(),
             service_version: env!("CARGO_PKG_VERSION").to_string(),
-            trace_exporter: ExporterType::Jaeger { endpoint: endpoint.to_string() },
+            trace_exporter: ExporterType::Jaeger {
+                endpoint: endpoint.to_string(),
+            },
             metrics_exporter: ExporterType::Prometheus { port: 9090 },
             logs_exporter: ExporterType::Console,
             sampling: SamplingStrategy::Ratio(0.1),
@@ -149,7 +160,9 @@ impl OtelConfig {
         Self {
             service_name: "vecstore".to_string(),
             service_version: env!("CARGO_PKG_VERSION").to_string(),
-            trace_exporter: ExporterType::Zipkin { endpoint: endpoint.to_string() },
+            trace_exporter: ExporterType::Zipkin {
+                endpoint: endpoint.to_string(),
+            },
             metrics_exporter: ExporterType::Prometheus { port: 9090 },
             logs_exporter: ExporterType::Console,
             sampling: SamplingStrategy::Ratio(0.1),
@@ -182,7 +195,8 @@ impl OtelConfig {
 
     /// Add resource attribute
     pub fn with_attribute(mut self, key: &str, value: &str) -> Self {
-        self.resource_attributes.insert(key.to_string(), value.to_string());
+        self.resource_attributes
+            .insert(key.to_string(), value.to_string());
         self
     }
 
@@ -304,7 +318,9 @@ impl Span {
 
     /// Set error status
     pub fn set_error(&mut self, message: &str) {
-        self.status = SpanStatus::Error { message: message.to_string() };
+        self.status = SpanStatus::Error {
+            message: message.to_string(),
+        };
     }
 
     /// Set OK status
@@ -314,7 +330,9 @@ impl Span {
 
     /// Get duration
     pub fn duration(&self) -> Duration {
-        self.end_time.unwrap_or_else(Instant::now).duration_since(self.start_time)
+        self.end_time
+            .unwrap_or_else(Instant::now)
+            .duration_since(self.start_time)
     }
 }
 
@@ -375,7 +393,9 @@ pub struct VecStoreMetrics {
 impl VecStoreMetrics {
     /// Create new metrics
     pub fn new() -> Self {
-        let boundaries = vec![1.0, 5.0, 10.0, 25.0, 50.0, 100.0, 250.0, 500.0, 1000.0, 5000.0];
+        let boundaries = vec![
+            1.0, 5.0, 10.0, 25.0, 50.0, 100.0, 250.0, 500.0, 1000.0, 5000.0,
+        ];
         let buckets: Vec<AtomicU64> = (0..=boundaries.len()).map(|_| AtomicU64::new(0)).collect();
 
         Self {
@@ -396,10 +416,13 @@ impl VecStoreMetrics {
     /// Record query
     pub fn record_query(&self, latency_ms: f64) {
         self.query_count.fetch_add(1, Ordering::Relaxed);
-        self.query_latency_sum.fetch_add((latency_ms * 1000.0) as u64, Ordering::Relaxed);
+        self.query_latency_sum
+            .fetch_add((latency_ms * 1000.0) as u64, Ordering::Relaxed);
 
         // Update histogram
-        let Ok(buckets) = self.histogram_buckets.read() else { return; };
+        let Ok(buckets) = self.histogram_buckets.read() else {
+            return;
+        };
         for (i, &boundary) in self.histogram_boundaries.iter().enumerate() {
             if latency_ms <= boundary {
                 buckets[i].fetch_add(1, Ordering::Relaxed);
@@ -419,7 +442,10 @@ impl VecStoreMetrics {
     /// Record delete
     pub fn record_delete(&self, count: usize) {
         self.delete_count.fetch_add(count as u64, Ordering::Relaxed);
-        self.vector_count.fetch_sub(count.min(self.vector_count.load(Ordering::Relaxed)), Ordering::Relaxed);
+        self.vector_count.fetch_sub(
+            count.min(self.vector_count.load(Ordering::Relaxed)),
+            Ordering::Relaxed,
+        );
     }
 
     /// Record cache hit
@@ -502,10 +528,14 @@ impl VecStoreMetrics {
         ));
 
         // Histogram
-        output.push_str("# HELP vecstore_query_latency_ms Query latency in milliseconds\n\
-                        # TYPE vecstore_query_latency_ms histogram\n");
+        output.push_str(
+            "# HELP vecstore_query_latency_ms Query latency in milliseconds\n\
+                        # TYPE vecstore_query_latency_ms histogram\n",
+        );
 
-        let Ok(buckets) = self.histogram_buckets.read() else { return output; };
+        let Ok(buckets) = self.histogram_buckets.read() else {
+            return output;
+        };
         let mut cumulative = 0u64;
         for (i, boundary) in self.histogram_boundaries.iter().enumerate() {
             cumulative += buckets[i].load(Ordering::Relaxed);
@@ -515,11 +545,18 @@ impl VecStoreMetrics {
             ));
         }
         cumulative += buckets[self.histogram_boundaries.len()].load(Ordering::Relaxed);
-        output.push_str(&format!("vecstore_query_latency_ms_bucket{{le=\"+Inf\"}} {}\n", cumulative));
-        output.push_str(&format!("vecstore_query_latency_ms_sum {}\n",
-            self.query_latency_sum.load(Ordering::Relaxed) as f64 / 1000.0));
-        output.push_str(&format!("vecstore_query_latency_ms_count {}\n",
-            self.query_count.load(Ordering::Relaxed)));
+        output.push_str(&format!(
+            "vecstore_query_latency_ms_bucket{{le=\"+Inf\"}} {}\n",
+            cumulative
+        ));
+        output.push_str(&format!(
+            "vecstore_query_latency_ms_sum {}\n",
+            self.query_latency_sum.load(Ordering::Relaxed) as f64 / 1000.0
+        ));
+        output.push_str(&format!(
+            "vecstore_query_latency_ms_count {}\n",
+            self.query_count.load(Ordering::Relaxed)
+        ));
 
         output
     }
@@ -600,12 +637,16 @@ impl TelemetryProvider {
         let span_id = span.span_id.clone();
 
         {
-            let Ok(mut current) = self.current_trace.write() else { return span_id; };
+            let Ok(mut current) = self.current_trace.write() else {
+                return span_id;
+            };
             *current = Some(trace_id.clone());
         }
 
         {
-            let Ok(mut spans) = self.spans.write() else { return span_id; };
+            let Ok(mut spans) = self.spans.write() else {
+                return span_id;
+            };
             spans.insert(span_id.clone(), span);
         }
 
@@ -614,7 +655,9 @@ impl TelemetryProvider {
 
     /// Start child span
     pub fn start_span(&self, name: &str, parent_id: Option<&str>) -> String {
-        let trace_id = self.current_trace.read()
+        let trace_id = self
+            .current_trace
+            .read()
             .ok()
             .and_then(|guard| guard.clone())
             .unwrap_or_else(generate_trace_id);
@@ -623,7 +666,9 @@ impl TelemetryProvider {
         let span_id = span.span_id.clone();
 
         {
-            let Ok(mut spans) = self.spans.write() else { return span_id; };
+            let Ok(mut spans) = self.spans.write() else {
+                return span_id;
+            };
             spans.insert(span_id.clone(), span);
         }
 
@@ -633,20 +678,26 @@ impl TelemetryProvider {
     /// End span
     pub fn end_span(&self, span_id: &str) {
         let span = {
-            let Ok(mut spans) = self.spans.write() else { return; };
+            let Ok(mut spans) = self.spans.write() else {
+                return;
+            };
             spans.remove(span_id)
         };
 
         if let Some(mut span) = span {
             span.end();
-            let Ok(mut completed) = self.completed_spans.write() else { return; };
+            let Ok(mut completed) = self.completed_spans.write() else {
+                return;
+            };
             completed.push(span);
         }
     }
 
     /// Set span attribute
     pub fn set_span_attribute(&self, span_id: &str, key: &str, value: SpanAttribute) {
-        let Ok(mut spans) = self.spans.write() else { return; };
+        let Ok(mut spans) = self.spans.write() else {
+            return;
+        };
         if let Some(span) = spans.get_mut(span_id) {
             span.set_attribute(key, value);
         }
@@ -654,7 +705,9 @@ impl TelemetryProvider {
 
     /// Set span error
     pub fn set_span_error(&self, span_id: &str, message: &str) {
-        let Ok(mut spans) = self.spans.write() else { return; };
+        let Ok(mut spans) = self.spans.write() else {
+            return;
+        };
         if let Some(span) = spans.get_mut(span_id) {
             span.set_error(message);
         }
@@ -666,15 +719,25 @@ impl TelemetryProvider {
 
         // Create a span for the query
         let span_id = self.start_span(operation, None);
-        self.set_span_attribute(&span_id, "db.system", SpanAttribute::String("vecstore".to_string()));
-        self.set_span_attribute(&span_id, "db.operation", SpanAttribute::String(operation.to_string()));
+        self.set_span_attribute(
+            &span_id,
+            "db.system",
+            SpanAttribute::String("vecstore".to_string()),
+        );
+        self.set_span_attribute(
+            &span_id,
+            "db.operation",
+            SpanAttribute::String(operation.to_string()),
+        );
         self.set_span_attribute(&span_id, "db.latency_ms", SpanAttribute::Float(latency_ms));
         self.end_span(&span_id);
     }
 
     /// Flush completed spans
     pub fn flush(&self) -> Vec<Span> {
-        let Ok(mut completed) = self.completed_spans.write() else { return Vec::new(); };
+        let Ok(mut completed) = self.completed_spans.write() else {
+            return Vec::new();
+        };
         std::mem::take(&mut *completed)
     }
 
@@ -686,22 +749,27 @@ impl TelemetryProvider {
         OtlpExportData {
             service_name: self.config.service_name.clone(),
             service_version: self.config.service_version.clone(),
-            spans: spans.into_iter().map(|s| OtlpSpan {
-                trace_id: s.trace_id,
-                span_id: s.span_id,
-                parent_span_id: s.parent_id,
-                name: s.name,
-                start_time_unix_nano: 0, // Would be real timestamp
-                end_time_unix_nano: 0,
-                attributes: s.attributes.into_iter()
-                    .map(|(k, v)| (k, format!("{:?}", v)))
-                    .collect(),
-                status: match s.status {
-                    SpanStatus::Ok => "OK".to_string(),
-                    SpanStatus::Error { message } => format!("ERROR: {}", message),
-                    SpanStatus::Unset => "UNSET".to_string(),
-                },
-            }).collect(),
+            spans: spans
+                .into_iter()
+                .map(|s| OtlpSpan {
+                    trace_id: s.trace_id,
+                    span_id: s.span_id,
+                    parent_span_id: s.parent_id,
+                    name: s.name,
+                    start_time_unix_nano: 0, // Would be real timestamp
+                    end_time_unix_nano: 0,
+                    attributes: s
+                        .attributes
+                        .into_iter()
+                        .map(|(k, v)| (k, format!("{:?}", v)))
+                        .collect(),
+                    status: match s.status {
+                        SpanStatus::Ok => "OK".to_string(),
+                        SpanStatus::Error { message } => format!("ERROR: {}", message),
+                        SpanStatus::Unset => "UNSET".to_string(),
+                    },
+                })
+                .collect(),
             metrics,
         }
     }
@@ -818,7 +886,10 @@ impl TraceContext {
 
     /// Convert to W3C traceparent header
     pub fn to_traceparent(&self) -> String {
-        format!("00-{}-{}-{:02x}", self.trace_id, self.span_id, self.trace_flags)
+        format!(
+            "00-{}-{}-{:02x}",
+            self.trace_id, self.span_id, self.trace_flags
+        )
     }
 }
 
diff --git a/src/partition_keys.rs b/src/partition_keys.rs
index 15d06bb..8c3f6b8 100644
--- a/src/partition_keys.rs
+++ b/src/partition_keys.rs
@@ -32,11 +32,11 @@
 //! let all_results = index.search_all_partitions(&query, 10)?;
 //! ```
 
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::{Arc, RwLock};
-use serde::{Deserialize, Serialize};
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 // ============================================================================
 // CONFIGURATION
@@ -241,7 +241,11 @@ impl Partition {
     pub fn get(&self, id: &str) -> Option<(Vec<f32>, Option<serde_json::Value>)> {
         let vectors = self.vectors.read().ok()?;
         vectors.get(id).map(|v| {
-            let meta = self.vector_metadata.read().ok().and_then(|m| m.get(id).cloned());
+            let meta = self
+                .vector_metadata
+                .read()
+                .ok()
+                .and_then(|m| m.get(id).cloned());
             (v.clone(), meta)
         })
     }
@@ -252,7 +256,8 @@ impl Partition {
             return Vec::new();
         };
 
-        let mut results: Vec<_> = vectors.iter()
+        let mut results: Vec<_> = vectors
+            .iter()
             .map(|(id, vec)| {
                 let score = cosine_similarity(query, vec);
                 (id.clone(), score)
@@ -264,7 +269,8 @@ impl Partition {
 
         let partition_id = self.meta.read().map(|m| m.id).unwrap_or(0);
 
-        results.into_iter()
+        results
+            .into_iter()
             .map(|(id, score)| PartitionSearchResult {
                 id,
                 score,
@@ -275,17 +281,20 @@ impl Partition {
 
     /// Get partition metadata
     pub fn meta(&self) -> PartitionMeta {
-        self.meta.read().map(|m| m.clone()).unwrap_or_else(|_| PartitionMeta {
-            id: 0,
-            key_value: String::new(),
-            state: PartitionState::Active,
-            created_at: 0,
-            last_accessed: 0,
-            vector_count: 0,
-            deleted_count: 0,
-            ttl_expiry: 0,
-            metadata: None,
-        })
+        self.meta
+            .read()
+            .map(|m| m.clone())
+            .unwrap_or_else(|_| PartitionMeta {
+                id: 0,
+                key_value: String::new(),
+                state: PartitionState::Active,
+                created_at: 0,
+                last_accessed: 0,
+                vector_count: 0,
+                deleted_count: 0,
+                ttl_expiry: 0,
+                metadata: None,
+            })
     }
 
     /// Check if compaction is needed
@@ -296,7 +305,8 @@ impl Partition {
         if meta.vector_count == 0 {
             return false;
         }
-        let delete_ratio = meta.deleted_count as f32 / (meta.vector_count + meta.deleted_count) as f32;
+        let delete_ratio =
+            meta.deleted_count as f32 / (meta.vector_count + meta.deleted_count) as f32;
         delete_ratio > threshold
     }
 
@@ -381,18 +391,18 @@ impl PartitionedIndex {
                     h ^= h >> 47;
                 }
                 h % self.config.max_partitions as u64
-            }
+            },
             HashAlgorithm::XXHash => {
                 use std::collections::hash_map::DefaultHasher;
                 use std::hash::{Hash, Hasher};
                 let mut hasher = DefaultHasher::new();
                 key_value.hash(&mut hasher);
                 hasher.finish() % self.config.max_partitions as u64
-            }
+            },
             HashAlgorithm::Modulo => {
                 // For testing - just use first char
                 key_value.bytes().next().unwrap_or(0) as u64 % self.config.max_partitions as u64
-            }
+            },
         }
     }
 
@@ -441,23 +451,20 @@ impl PartitionedIndex {
 
     /// Extract partition key from metadata
     fn extract_partition_key(&self, metadata: &serde_json::Value) -> Option<String> {
-        metadata.get(&self.config.partition_key)
+        metadata
+            .get(&self.config.partition_key)
             .and_then(|v| v.as_str())
             .map(String::from)
     }
 
     /// Insert or update a vector
-    pub fn upsert(
-        &self,
-        id: &str,
-        vector: Vec<f32>,
-        metadata: serde_json::Value,
-    ) -> Result<()> {
-        let key_value = self.extract_partition_key(&metadata)
-            .ok_or_else(|| VecStoreError::InvalidInput(format!(
+    pub fn upsert(&self, id: &str, vector: Vec<f32>, metadata: serde_json::Value) -> Result<()> {
+        let key_value = self.extract_partition_key(&metadata).ok_or_else(|| {
+            VecStoreError::InvalidInput(format!(
                 "Missing partition key: {}",
                 self.config.partition_key
-            )))?;
+            ))
+        })?;
 
         let partition = self.get_or_create_partition(&key_value)?;
         partition.upsert(id, vector, Some(metadata))?;
@@ -510,7 +517,7 @@ impl PartitionedIndex {
     ) -> Result<Vec<PartitionSearchResult>> {
         if !self.config.allow_cross_partition {
             return Err(VecStoreError::InvalidInput(
-                "Cross-partition queries not allowed".to_string()
+                "Cross-partition queries not allowed".to_string(),
             ));
         }
 
@@ -559,7 +566,10 @@ impl PartitionedIndex {
 
     /// List all partitions
     pub fn list_partitions(&self) -> Vec<PartitionMeta> {
-        self.partitions.read().map(|p| p.values().map(|p| p.meta()).collect()).unwrap_or_default()
+        self.partitions
+            .read()
+            .map(|p| p.values().map(|p| p.meta()).collect())
+            .unwrap_or_default()
     }
 
     /// Drop a partition
@@ -668,12 +678,18 @@ impl PartitionRouter {
 
     /// Get hot partitions
     pub fn hot_partitions(&self) -> Vec<u64> {
-        self.hot_partitions.read().map(|h| h.clone()).unwrap_or_default()
+        self.hot_partitions
+            .read()
+            .map(|h| h.clone())
+            .unwrap_or_default()
     }
 
     /// Get cold partitions (candidates for archival)
     pub fn cold_partitions(&self) -> Vec<u64> {
-        self.cold_partitions.read().map(|c| c.clone()).unwrap_or_default()
+        self.cold_partitions
+            .read()
+            .map(|c| c.clone())
+            .unwrap_or_default()
     }
 
     /// Reset access counts (call periodically)
@@ -721,8 +737,12 @@ mod tests {
     fn test_partition() {
         let partition = Partition::new(1, "tenant_a", 4);
 
-        partition.upsert("doc1", vec![1.0, 0.0, 0.0, 0.0], None).unwrap();
-        partition.upsert("doc2", vec![0.0, 1.0, 0.0, 0.0], None).unwrap();
+        partition
+            .upsert("doc1", vec![1.0, 0.0, 0.0, 0.0], None)
+            .unwrap();
+        partition
+            .upsert("doc2", vec![0.0, 1.0, 0.0, 0.0], None)
+            .unwrap();
 
         let results = partition.search(&[1.0, 0.0, 0.0, 0.0], 10);
         assert_eq!(results.len(), 2);
@@ -738,13 +758,25 @@ mod tests {
         let index = PartitionedIndex::new(4, config).unwrap();
 
         // Insert to different partitions
-        index.upsert("doc1", vec![1.0, 0.0, 0.0, 0.0], serde_json::json!({
-            "tenant_id": "acme"
-        })).unwrap();
-
-        index.upsert("doc2", vec![0.0, 1.0, 0.0, 0.0], serde_json::json!({
-            "tenant_id": "globex"
-        })).unwrap();
+        index
+            .upsert(
+                "doc1",
+                vec![1.0, 0.0, 0.0, 0.0],
+                serde_json::json!({
+                    "tenant_id": "acme"
+                }),
+            )
+            .unwrap();
+
+        index
+            .upsert(
+                "doc2",
+                vec![0.0, 1.0, 0.0, 0.0],
+                serde_json::json!({
+                    "tenant_id": "globex"
+                }),
+            )
+            .unwrap();
 
         // Search within partition
         let results = index.search(&[1.0, 0.0, 0.0, 0.0], 10, "acme").unwrap();
@@ -759,14 +791,19 @@ mod tests {
 
     #[test]
     fn test_partition_listing() {
-        let config = PartitionConfig::new()
-            .with_partition_key("tenant_id");
+        let config = PartitionConfig::new().with_partition_key("tenant_id");
 
         let index = PartitionedIndex::new(4, config).unwrap();
 
-        index.upsert("doc1", vec![1.0; 4], serde_json::json!({"tenant_id": "a"})).unwrap();
-        index.upsert("doc2", vec![1.0; 4], serde_json::json!({"tenant_id": "b"})).unwrap();
-        index.upsert("doc3", vec![1.0; 4], serde_json::json!({"tenant_id": "c"})).unwrap();
+        index
+            .upsert("doc1", vec![1.0; 4], serde_json::json!({"tenant_id": "a"}))
+            .unwrap();
+        index
+            .upsert("doc2", vec![1.0; 4], serde_json::json!({"tenant_id": "b"}))
+            .unwrap();
+        index
+            .upsert("doc3", vec![1.0; 4], serde_json::json!({"tenant_id": "c"}))
+            .unwrap();
 
         let partitions = index.list_partitions();
         assert_eq!(partitions.len(), 3);
diff --git a/src/partitioning.rs b/src/partitioning.rs
index c25780e..d7a98ee 100644
--- a/src/partitioning.rs
+++ b/src/partitioning.rs
@@ -152,11 +152,11 @@ impl PartitionedStore {
 
                             self.partitions.insert(partition_id.clone(), store);
                             self.partition_info.insert(partition_id, info);
-                        }
+                        },
                         Err(_) => {
                             // Skip corrupted partitions
                             continue;
-                        }
+                        },
                     }
                 }
             }
@@ -210,13 +210,14 @@ impl PartitionedStore {
         // Check partition size limit
         if let Some(max_size) = self.config.max_vectors_per_partition
             && let Some(info) = self.partition_info.get(partition_id)
-                && info.vector_count >= max_size {
-                    return Err(anyhow::anyhow!(
-                        "Partition '{}' has reached maximum size of {} vectors",
-                        partition_id,
-                        max_size
-                    ));
-                }
+            && info.vector_count >= max_size
+        {
+            return Err(anyhow::anyhow!(
+                "Partition '{}' has reached maximum size of {} vectors",
+                partition_id,
+                max_size
+            ));
+        }
 
         let partition = self.get_or_create_partition(partition_id)?;
         partition.upsert(id, vector, metadata)?;
diff --git a/src/payload_index.rs b/src/payload_index.rs
index 7b408ea..504280e 100644
--- a/src/payload_index.rs
+++ b/src/payload_index.rs
@@ -38,12 +38,12 @@
 //! let matching_ids = manager.query(&filter)?;
 //! ```
 
-use std::collections::{HashMap, HashSet, BTreeMap};
-use std::sync::RwLock;
-use serde::{Deserialize, Serialize};
 use ordered_float::OrderedFloat;
+use serde::{Deserialize, Serialize};
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::sync::RwLock;
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 // ============================================================================
 // INDEX TYPES
@@ -102,12 +102,13 @@ impl HashIndex {
     pub fn insert(&mut self, doc_id: &str, value: &str) {
         // Remove old value if exists
         if let Some(old_value) = self.reverse.remove(doc_id)
-            && let Some(docs) = self.index.get_mut(&old_value) {
-                docs.remove(doc_id);
-                if docs.is_empty() {
-                    self.index.remove(&old_value);
-                }
+            && let Some(docs) = self.index.get_mut(&old_value)
+        {
+            docs.remove(doc_id);
+            if docs.is_empty() {
+                self.index.remove(&old_value);
             }
+        }
 
         // Insert new value
         self.index
@@ -120,12 +121,13 @@ impl HashIndex {
     /// Remove a document
     pub fn remove(&mut self, doc_id: &str) {
         if let Some(value) = self.reverse.remove(doc_id)
-            && let Some(docs) = self.index.get_mut(&value) {
-                docs.remove(doc_id);
-                if docs.is_empty() {
-                    self.index.remove(&value);
-                }
+            && let Some(docs) = self.index.get_mut(&value)
+        {
+            docs.remove(doc_id);
+            if docs.is_empty() {
+                self.index.remove(&value);
             }
+        }
     }
 
     /// Get documents with exact value
@@ -186,12 +188,13 @@ impl BTreeIndex {
 
         // Remove old value if exists
         if let Some(old_value) = self.reverse.remove(doc_id)
-            && let Some(docs) = self.index.get_mut(&old_value) {
-                docs.remove(doc_id);
-                if docs.is_empty() {
-                    self.index.remove(&old_value);
-                }
+            && let Some(docs) = self.index.get_mut(&old_value)
+        {
+            docs.remove(doc_id);
+            if docs.is_empty() {
+                self.index.remove(&old_value);
             }
+        }
 
         // Insert new value
         self.index
@@ -204,12 +207,13 @@ impl BTreeIndex {
     /// Remove a document
     pub fn remove(&mut self, doc_id: &str) {
         if let Some(value) = self.reverse.remove(doc_id)
-            && let Some(docs) = self.index.get_mut(&value) {
-                docs.remove(doc_id);
-                if docs.is_empty() {
-                    self.index.remove(&value);
-                }
+            && let Some(docs) = self.index.get_mut(&value)
+        {
+            docs.remove(doc_id);
+            if docs.is_empty() {
+                self.index.remove(&value);
             }
+        }
     }
 
     /// Get documents in range [min, max]
@@ -291,8 +295,7 @@ impl GeoPoint {
         let dlat = (other.lat - self.lat).to_radians();
         let dlon = (other.lon - self.lon).to_radians();
 
-        let a = (dlat / 2.0).sin().powi(2)
-            + lat1.cos() * lat2.cos() * (dlon / 2.0).sin().powi(2);
+        let a = (dlat / 2.0).sin().powi(2) + lat1.cos() * lat2.cos() * (dlon / 2.0).sin().powi(2);
         let c = 2.0 * a.sqrt().asin();
 
         r * c
@@ -411,12 +414,12 @@ impl GeoIndex {
                     for doc_id in docs {
                         if let Some(point) = self.points.get(doc_id)
                             && point.lat >= min_lat
-                                && point.lat <= max_lat
-                                && point.lon >= min_lon
-                                && point.lon <= max_lon
-                            {
-                                results.insert(doc_id.clone());
-                            }
+                            && point.lat <= max_lat
+                            && point.lon >= min_lon
+                            && point.lon <= max_lon
+                        {
+                            results.insert(doc_id.clone());
+                        }
                     }
                 }
             }
@@ -585,22 +588,22 @@ impl PayloadIndexManager {
                 self.hash_indexes
                     .write()?
                     .insert(field.to_string(), HashIndex::new(field));
-            }
+            },
             IndexType::BTree => {
                 self.btree_indexes
                     .write()?
                     .insert(field.to_string(), BTreeIndex::new(field));
-            }
+            },
             IndexType::Geo => {
                 self.geo_indexes
                     .write()?
                     .insert(field.to_string(), GeoIndex::new(field, 0.1));
-            }
+            },
             IndexType::FullText => {
                 self.fulltext_indexes
                     .write()?
                     .insert(field.to_string(), FullTextIndex::new(field));
-            }
+            },
         }
         Ok(())
     }
@@ -629,9 +632,10 @@ impl PayloadIndexManager {
             for (field, value) in map {
                 // Hash index
                 if let Some(idx) = self.hash_indexes.write()?.get_mut(field)
-                    && let Some(s) = value.as_str() {
-                        idx.insert(doc_id, s);
-                    }
+                    && let Some(s) = value.as_str()
+                {
+                    idx.insert(doc_id, s);
+                }
 
                 // B-tree index
                 if let Some(idx) = self.btree_indexes.write()?.get_mut(field) {
@@ -645,18 +649,20 @@ impl PayloadIndexManager {
                 // Geo index
                 if let Some(idx) = self.geo_indexes.write()?.get_mut(field)
                     && let serde_json::Value::Object(geo) = value
-                        && let (Some(lat), Some(lon)) = (
-                            geo.get("lat").and_then(|v| v.as_f64()),
-                            geo.get("lon").and_then(|v| v.as_f64()),
-                        ) {
-                            idx.insert(doc_id, GeoPoint::new(lat, lon));
-                        }
+                    && let (Some(lat), Some(lon)) = (
+                        geo.get("lat").and_then(|v| v.as_f64()),
+                        geo.get("lon").and_then(|v| v.as_f64()),
+                    )
+                {
+                    idx.insert(doc_id, GeoPoint::new(lat, lon));
+                }
 
                 // Full-text index
                 if let Some(idx) = self.fulltext_indexes.write()?.get_mut(field)
-                    && let Some(s) = value.as_str() {
-                        idx.insert(doc_id, s);
-                    }
+                    && let Some(s) = value.as_str()
+                {
+                    idx.insert(doc_id, s);
+                }
             }
         }
         Ok(())
@@ -703,7 +709,7 @@ impl PayloadIndexManager {
                         field
                     )))
                 }
-            }
+            },
             Filter::In { field, values } => {
                 let guard = self.hash_indexes.read()?;
                 if let Some(idx) = guard.get(field) {
@@ -714,7 +720,7 @@ impl PayloadIndexManager {
                         field
                     )))
                 }
-            }
+            },
             Filter::Range { field, min, max } => {
                 let guard = self.btree_indexes.read()?;
                 if let Some(idx) = guard.get(field) {
@@ -725,7 +731,7 @@ impl PayloadIndexManager {
                         field
                     )))
                 }
-            }
+            },
             Filter::Gt { field, value } => {
                 let guard = self.btree_indexes.read()?;
                 if let Some(idx) = guard.get(field) {
@@ -736,7 +742,7 @@ impl PayloadIndexManager {
                         field
                     )))
                 }
-            }
+            },
             Filter::Lt { field, value } => {
                 let guard = self.btree_indexes.read()?;
                 if let Some(idx) = guard.get(field) {
@@ -747,8 +753,12 @@ impl PayloadIndexManager {
                         field
                     )))
                 }
-            }
-            Filter::GeoRadius { field, center, radius_km } => {
+            },
+            Filter::GeoRadius {
+                field,
+                center,
+                radius_km,
+            } => {
                 let guard = self.geo_indexes.read()?;
                 if let Some(idx) = guard.get(field) {
                     let results = idx.within_radius(center, *radius_km);
@@ -759,7 +769,7 @@ impl PayloadIndexManager {
                         field
                     )))
                 }
-            }
+            },
             Filter::FullText { field, query } => {
                 let guard = self.fulltext_indexes.read()?;
                 if let Some(idx) = guard.get(field) {
@@ -770,7 +780,7 @@ impl PayloadIndexManager {
                         field
                     )))
                 }
-            }
+            },
             Filter::And(filters) => {
                 let mut result: Option<HashSet<String>> = None;
                 for f in filters {
@@ -781,21 +791,21 @@ impl PayloadIndexManager {
                     });
                 }
                 Ok(result.unwrap_or_default())
-            }
+            },
             Filter::Or(filters) => {
                 let mut result = HashSet::new();
                 for f in filters {
                     result.extend(self.evaluate_filter(f)?);
                 }
                 Ok(result)
-            }
+            },
             Filter::Not(_inner) => {
                 // Would need all document IDs to compute NOT
                 // For now, return empty (would need enhancement)
                 Err(VecStoreError::InvalidInput(
                     "NOT filter requires full document list".to_string(),
                 ))
-            }
+            },
         }
     }
 
@@ -852,7 +862,11 @@ pub enum Filter {
     /// Less than
     Lt { field: String, value: f64 },
     /// Geo radius query
-    GeoRadius { field: String, center: GeoPoint, radius_km: f64 },
+    GeoRadius {
+        field: String,
+        center: GeoPoint,
+        radius_km: f64,
+    },
     /// Full-text search
     FullText { field: String, query: String },
     /// AND of filters
@@ -996,10 +1010,15 @@ mod tests {
         manager.create_index("category", IndexType::Hash).unwrap();
         manager.create_index("price", IndexType::BTree).unwrap();
 
-        manager.index_payload("doc1", &serde_json::json!({
-            "category": "electronics",
-            "price": 299.99
-        })).unwrap();
+        manager
+            .index_payload(
+                "doc1",
+                &serde_json::json!({
+                    "category": "electronics",
+                    "price": 299.99
+                }),
+            )
+            .unwrap();
 
         let filter = Filter::and(vec![
             Filter::eq("category", "electronics"),
diff --git a/src/pq.rs b/src/pq.rs
index cda8cf4..bf7acb7 100644
--- a/src/pq.rs
+++ b/src/pq.rs
@@ -49,9 +49,9 @@
 //! let distance = pq.asymmetric_distance(&query, &codes)?;
 //! ```
 
-use anyhow::{anyhow, Result};
-use rand::seq::SliceRandom;
+use anyhow::{Result, anyhow};
 use rand::Rng;
+use rand::seq::SliceRandom;
 use serde::{Deserialize, Serialize};
 
 // ============================================================================
@@ -296,7 +296,11 @@ impl ProductQuantizer {
                 .iter()
                 .map(|v| {
                     let mut recon = vec![0.0; d];
-                    for (m, codebook) in temp_codebooks.iter().enumerate().take(self.config.num_subspaces) {
+                    for (m, codebook) in temp_codebooks
+                        .iter()
+                        .enumerate()
+                        .take(self.config.num_subspaces)
+                    {
                         let start_dim = m * self.subspace_dim;
                         let end_dim = start_dim + self.subspace_dim;
                         let subvec = &v[start_dim..end_dim];
@@ -499,7 +503,8 @@ impl ProductQuantizer {
     /// Find nearest centroid index
     #[inline]
     fn find_nearest_centroid(&self, vector: &[f32], centroids: &[Vec<f32>]) -> usize {
-        self.find_nearest_centroid_with_distance(vector, centroids).0
+        self.find_nearest_centroid_with_distance(vector, centroids)
+            .0
     }
 
     /// Find nearest centroid with distance
@@ -639,11 +644,11 @@ impl ProductQuantizer {
             match self.config.metric {
                 PQMetric::L2 => {
                     distance += self.l2_distance_squared(query_subvec, centroid);
-                }
+                },
                 PQMetric::InnerProduct => {
                     let ip: f32 = query_subvec.iter().zip(centroid).map(|(a, b)| a * b).sum();
                     distance -= ip; // Negate for "lower is better"
-                }
+                },
             }
         }
 
@@ -680,9 +685,11 @@ impl ProductQuantizer {
                 .iter()
                 .map(|centroid| match self.config.metric {
                     PQMetric::L2 => self.l2_distance_squared(query_subvec, centroid),
-                    PQMetric::InnerProduct => {
-                        -query_subvec.iter().zip(centroid).map(|(a, b)| a * b).sum::<f32>()
-                    }
+                    PQMetric::InnerProduct => -query_subvec
+                        .iter()
+                        .zip(centroid)
+                        .map(|(a, b)| a * b)
+                        .sum::<f32>(),
                 })
                 .collect();
 
diff --git a/src/privacy.rs b/src/privacy.rs
index c6eadf4..41477fe 100644
--- a/src/privacy.rs
+++ b/src/privacy.rs
@@ -31,10 +31,10 @@
 //! let private_query = engine.privatize_query(&query_vector)?;
 //! ```
 
-use std::collections::HashMap;
-use std::sync::{Arc, RwLock};
 use rand_distr::{Distribution, Normal};
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
 
 use crate::error::VecStoreError;
 
@@ -63,8 +63,7 @@ impl Distribution<f64> for Laplace {
 }
 
 /// Differential privacy mechanism
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
-#[derive(Default)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Default)]
 pub enum DPMechanism {
     /// Laplace mechanism (pure DP)
     Laplace,
@@ -77,7 +76,6 @@ pub enum DPMechanism {
     RandomizedResponse,
 }
 
-
 /// Privacy configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PrivacyConfig {
@@ -185,8 +183,14 @@ impl PrivacyBudget {
     }
 
     /// Spend budget for a specific entity
-    pub fn spend_entity(&mut self, entity_id: &str, epsilon: f64, delta: f64) -> Result<(), VecStoreError> {
-        let entry = self.entity_budgets
+    pub fn spend_entity(
+        &mut self,
+        entity_id: &str,
+        epsilon: f64,
+        delta: f64,
+    ) -> Result<(), VecStoreError> {
+        let entry = self
+            .entity_budgets
             .entry(entity_id.to_string())
             .or_insert_with(|| EntityBudget {
                 epsilon_spent: 0.0,
@@ -252,9 +256,10 @@ impl PrivacyEngine {
     pub fn privatize(&self, vector: &[f32]) -> Result<Vec<f32>, VecStoreError> {
         // Track budget if enabled
         if self.config.track_budget {
-            let mut budget = self.budget.write().map_err(|_| {
-                VecStoreError::Internal("Failed to acquire budget lock".into())
-            })?;
+            let mut budget = self
+                .budget
+                .write()
+                .map_err(|_| VecStoreError::Internal("Failed to acquire budget lock".into()))?;
             budget.spend(self.config.epsilon, self.config.delta)?;
         }
 
@@ -272,9 +277,9 @@ impl PrivacyEngine {
             DPMechanism::DiscreteLaplace => self.add_discrete_laplace_noise(&clipped)?,
             DPMechanism::RandomizedResponse => {
                 return Err(VecStoreError::InvalidInput(
-                    "RandomizedResponse not applicable to continuous vectors".into()
+                    "RandomizedResponse not applicable to continuous vectors".into(),
                 ));
-            }
+            },
         };
 
         Ok(noisy)
@@ -286,9 +291,10 @@ impl PrivacyEngine {
         let query_epsilon = self.config.epsilon * 0.1; // Use 10% of vector budget
 
         if self.config.track_budget {
-            let mut budget = self.budget.write().map_err(|_| {
-                VecStoreError::Internal("Failed to acquire budget lock".into())
-            })?;
+            let mut budget = self
+                .budget
+                .write()
+                .map_err(|_| VecStoreError::Internal("Failed to acquire budget lock".into()))?;
             budget.spend(query_epsilon, self.config.delta * 0.1)?;
         }
 
@@ -311,9 +317,10 @@ impl PrivacyEngine {
         let batch_epsilon = self.config.epsilon * n.sqrt(); // Sublinear in batch size
 
         if self.config.track_budget {
-            let mut budget = self.budget.write().map_err(|_| {
-                VecStoreError::Internal("Failed to acquire budget lock".into())
-            })?;
+            let mut budget = self
+                .budget
+                .write()
+                .map_err(|_| VecStoreError::Internal("Failed to acquire budget lock".into()))?;
             budget.spend(batch_epsilon, self.config.delta * n)?;
         }
 
@@ -374,7 +381,8 @@ impl PrivacyEngine {
 
         // Round to reduce precision (increases k-anonymity)
         let precision = 1.0 / k_anonymity as f32;
-        let anonymized: Vec<f32> = noisy.iter()
+        let anonymized: Vec<f32> = noisy
+            .iter()
             .map(|&v| (v / precision).round() * precision)
             .collect();
 
@@ -388,11 +396,11 @@ impl PrivacyEngine {
                 // Gaussian mechanism: sigma = sensitivity * sqrt(2 * ln(1.25/delta)) / epsilon
                 let c = (2.0 * (1.25 / self.config.delta).ln()).sqrt();
                 self.config.sensitivity * c / self.config.epsilon
-            }
+            },
             DPMechanism::Laplace => {
                 // Laplace mechanism: scale = sensitivity / epsilon
                 self.config.sensitivity / self.config.epsilon
-            }
+            },
             _ => self.config.sensitivity / self.config.epsilon,
         }
     }
@@ -410,7 +418,8 @@ impl PrivacyEngine {
         };
 
         // Signal magnitude
-        let signal_mag: f64 = sample_vector.iter()
+        let signal_mag: f64 = sample_vector
+            .iter()
             .map(|&v| (v as f64) * (v as f64))
             .sum::<f64>()
             .sqrt();
@@ -437,27 +446,30 @@ impl PrivacyEngine {
 
     /// Get remaining privacy budget
     pub fn remaining_budget(&self) -> Result<(f64, f64), VecStoreError> {
-        let budget = self.budget.read().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire budget lock".into())
-        })?;
+        let budget = self
+            .budget
+            .read()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire budget lock".into()))?;
 
         Ok(budget.remaining())
     }
 
     /// Check if privacy budget is exhausted
     pub fn is_budget_exhausted(&self) -> Result<bool, VecStoreError> {
-        let budget = self.budget.read().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire budget lock".into())
-        })?;
+        let budget = self
+            .budget
+            .read()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire budget lock".into()))?;
 
         Ok(budget.is_exhausted())
     }
 
     /// Reset privacy budget
     pub fn reset_budget(&self) -> Result<(), VecStoreError> {
-        let mut budget = self.budget.write().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire budget lock".into())
-        })?;
+        let mut budget = self
+            .budget
+            .write()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire budget lock".into()))?;
 
         *budget = PrivacyBudget::new(self.config.max_budget, self.config.delta * 100.0);
         Ok(())
@@ -465,9 +477,10 @@ impl PrivacyEngine {
 
     /// Get privacy budget snapshot
     pub fn get_budget_snapshot(&self) -> Result<PrivacyBudget, VecStoreError> {
-        let budget = self.budget.read().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire budget lock".into())
-        })?;
+        let budget = self
+            .budget
+            .read()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire budget lock".into()))?;
 
         Ok(budget.clone())
     }
@@ -479,13 +492,17 @@ impl PrivacyEngine {
         self.add_gaussian_noise_with_scale(vector, scale)
     }
 
-    fn add_gaussian_noise_with_scale(&self, vector: &[f32], scale: f64) -> Result<Vec<f32>, VecStoreError> {
-        let normal = Normal::new(0.0, scale).map_err(|e| {
-            VecStoreError::InvalidInput(format!("Invalid noise scale: {}", e))
-        })?;
+    fn add_gaussian_noise_with_scale(
+        &self,
+        vector: &[f32],
+        scale: f64,
+    ) -> Result<Vec<f32>, VecStoreError> {
+        let normal = Normal::new(0.0, scale)
+            .map_err(|e| VecStoreError::InvalidInput(format!("Invalid noise scale: {}", e)))?;
 
         let mut rng = rand::rng();
-        let noisy: Vec<f32> = vector.iter()
+        let noisy: Vec<f32> = vector
+            .iter()
             .map(|&v| v + normal.sample(&mut rng) as f32)
             .collect();
 
@@ -494,12 +511,12 @@ impl PrivacyEngine {
 
     fn add_laplace_noise(&self, vector: &[f32]) -> Result<Vec<f32>, VecStoreError> {
         let scale = self.config.sensitivity / self.config.epsilon;
-        let laplace = Laplace::new(0.0, scale).map_err(|e| {
-            VecStoreError::InvalidInput(format!("Invalid noise scale: {}", e))
-        })?;
+        let laplace = Laplace::new(0.0, scale)
+            .map_err(|e| VecStoreError::InvalidInput(format!("Invalid noise scale: {}", e)))?;
 
         let mut rng = rand::rng();
-        let noisy: Vec<f32> = vector.iter()
+        let noisy: Vec<f32> = vector
+            .iter()
             .map(|&v| v + laplace.sample(&mut rng) as f32)
             .collect();
 
@@ -509,12 +526,12 @@ impl PrivacyEngine {
     fn add_discrete_laplace_noise(&self, vector: &[f32]) -> Result<Vec<f32>, VecStoreError> {
         // Discretized Laplace for integer-like values
         let scale = self.config.sensitivity / self.config.epsilon;
-        let laplace = Laplace::new(0.0, scale).map_err(|e| {
-            VecStoreError::InvalidInput(format!("Invalid noise scale: {}", e))
-        })?;
+        let laplace = Laplace::new(0.0, scale)
+            .map_err(|e| VecStoreError::InvalidInput(format!("Invalid noise scale: {}", e)))?;
 
         let mut rng = rand::rng();
-        let noisy: Vec<f32> = vector.iter()
+        let noisy: Vec<f32> = vector
+            .iter()
             .map(|&v| {
                 let noise = laplace.sample(&mut rng).round() as f32;
                 v + noise
@@ -527,7 +544,8 @@ impl PrivacyEngine {
 
 /// Clip vector to have at most the given L2 norm
 fn clip_vector(vector: &[f32], max_norm: f64) -> Vec<f32> {
-    let current_norm: f64 = vector.iter()
+    let current_norm: f64 = vector
+        .iter()
         .map(|&v| (v as f64) * (v as f64))
         .sum::<f64>()
         .sqrt();
@@ -672,7 +690,8 @@ mod tests {
         assert_eq!(private.len(), original.len());
 
         // Should be different (with high probability)
-        let diff: f32 = original.iter()
+        let diff: f32 = original
+            .iter()
             .zip(private.iter())
             .map(|(a, b)| (a - b).abs())
             .sum();
@@ -685,7 +704,8 @@ mod tests {
         let clipped = clip_vector(&large_vec, 1.0);
 
         // Should have norm <= 1
-        let norm: f64 = clipped.iter()
+        let norm: f64 = clipped
+            .iter()
             .map(|&v| (v as f64) * (v as f64))
             .sum::<f64>()
             .sqrt();
@@ -828,7 +848,8 @@ mod tests {
         // Should be perturbed
         assert_eq!(private_query.len(), 3);
 
-        let diff: f32 = query.iter()
+        let diff: f32 = query
+            .iter()
             .zip(private_query.iter())
             .map(|(a, b)| (a - b).abs())
             .sum();
@@ -840,11 +861,7 @@ mod tests {
         let config = PrivacyConfig::default();
         let engine = PrivacyEngine::new(config);
 
-        let vectors = vec![
-            vec![1.0, 0.0],
-            vec![0.0, 1.0],
-            vec![0.5, 0.5],
-        ];
+        let vectors = vec![vec![1.0, 0.0], vec![0.0, 1.0], vec![0.5, 0.5]];
 
         let private = engine.privatize_batch(&vectors).unwrap();
 
diff --git a/src/profiler.rs b/src/profiler.rs
index 70f2d4a..564a74c 100644
--- a/src/profiler.rs
+++ b/src/profiler.rs
@@ -48,7 +48,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::time::Instant;
 
diff --git a/src/protocol.rs b/src/protocol.rs
index 152dbdd..1a2580a 100644
--- a/src/protocol.rs
+++ b/src/protocol.rs
@@ -42,7 +42,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::HashMap;
@@ -214,7 +214,7 @@ impl ProtocolAdapter {
             Protocol::Milvus => self.parse_milvus(json),
             Protocol::Universal => {
                 serde_json::from_str(json).map_err(|e| anyhow!("Invalid JSON: {}", e))
-            }
+            },
         }
     }
 
@@ -482,7 +482,7 @@ impl ProtocolAdapter {
                 Ok(UniversalResponse::Upsert {
                     upserted_count: count,
                 })
-            }
+            },
 
             UniversalRequest::Query {
                 vector,
@@ -521,7 +521,7 @@ impl ProtocolAdapter {
                     .collect();
 
                 Ok(UniversalResponse::Query { matches })
-            }
+            },
 
             UniversalRequest::Delete { ids } => {
                 let mut count = 0;
@@ -533,7 +533,7 @@ impl ProtocolAdapter {
                 Ok(UniversalResponse::Delete {
                     deleted_count: count,
                 })
-            }
+            },
 
             UniversalRequest::Fetch { ids } => {
                 let mut vectors = HashMap::new();
@@ -552,7 +552,7 @@ impl ProtocolAdapter {
                 }
 
                 Ok(UniversalResponse::Fetch { vectors })
-            }
+            },
         }
     }
 
@@ -564,7 +564,7 @@ impl ProtocolAdapter {
             // Universal and other protocols fall back to the native JSON format
             Protocol::Universal | Protocol::Weaviate | Protocol::ChromaDB | Protocol::Milvus => {
                 serde_json::to_string(&response).map_err(|e| anyhow!("Serialization error: {}", e))
-            }
+            },
         }
     }
 
@@ -575,18 +575,18 @@ impl ProtocolAdapter {
                 serde_json::json!({
                     "upsertedCount": upserted_count
                 })
-            }
+            },
             UniversalResponse::Query { matches } => {
                 serde_json::json!({
                     "matches": matches,
                     "namespace": ""
                 })
-            }
+            },
             UniversalResponse::Delete { deleted_count } => {
                 serde_json::json!({
                     "deletedCount": deleted_count
                 })
-            }
+            },
             _ => serde_json::json!(response),
         };
 
@@ -605,7 +605,7 @@ impl ProtocolAdapter {
                     "status": "ok",
                     "time": 0.0
                 })
-            }
+            },
             UniversalResponse::Query { matches } => {
                 let results: Vec<Value> = matches
                     .into_iter()
@@ -623,7 +623,7 @@ impl ProtocolAdapter {
                     "status": "ok",
                     "time": 0.0
                 })
-            }
+            },
             _ => serde_json::json!(response),
         };
 
@@ -688,7 +688,7 @@ impl ProtocolAdapter {
                             conditions.push(FilterExpr::And(sub_filters));
                         }
                     }
-                }
+                },
                 "$or" => {
                     if let Some(arr) = value.as_array() {
                         let sub_filters: Vec<FilterExpr> = arr
@@ -707,7 +707,7 @@ impl ProtocolAdapter {
                             conditions.push(FilterExpr::Or(sub_filters));
                         }
                     }
-                }
+                },
                 field => {
                     // Check if value is an operator object
                     if let Some(obj) = value.as_object() {
@@ -740,7 +740,7 @@ impl ProtocolAdapter {
                             value: value.clone(),
                         });
                     }
-                }
+                },
             }
         }
 
diff --git a/src/python.rs b/src/python.rs
index 9d3a15c..e3e1c0e 100644
--- a/src/python.rs
+++ b/src/python.rs
@@ -6,12 +6,12 @@
 // This module provides Python-friendly wrappers around the Rust API.
 
 use crate::collection::{Collection, VecDatabase};
-use crate::store::{parse_filter, FilterExpr, HybridQuery, Metadata, Query, VecStore};
+use crate::store::{FilterExpr, HybridQuery, Metadata, Query, VecStore, parse_filter};
 use crate::text_splitter::{RecursiveCharacterTextSplitter, TextSplitter};
+use pyo3::IntoPyObjectExt;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
-use pyo3::IntoPyObjectExt;
 use std::collections::HashMap;
 use std::path::PathBuf;
 
@@ -108,21 +108,21 @@ fn metadata_to_pydict(py: Python, metadata: &Metadata) -> PyResult<Py<PyDict>> {
         match value {
             serde_json::Value::String(s) => {
                 dict.set_item(key, s.as_str())?;
-            }
+            },
             serde_json::Value::Number(n) => {
                 if let Some(i) = n.as_i64() {
                     dict.set_item(key, i)?;
                 } else if let Some(f) = n.as_f64() {
                     dict.set_item(key, f)?;
                 }
-            }
+            },
             serde_json::Value::Bool(b) => {
                 dict.set_item(key, b)?;
-            }
+            },
             serde_json::Value::Null => {
                 dict.set_item(key, py.None())?;
-            }
-            _ => {} // Skip complex types
+            },
+            _ => {}, // Skip complex types
         }
     }
     Ok(dict.unbind())
@@ -803,7 +803,10 @@ impl PyLangChainVectorStore {
 
         for (i, (text, embedding)) in texts.into_iter().zip(embeddings).enumerate() {
             let id = if let Some(ref id_list) = ids {
-                id_list.get(i).cloned().unwrap_or_else(|| format!("doc_{}", i))
+                id_list
+                    .get(i)
+                    .cloned()
+                    .unwrap_or_else(|| format!("doc_{}", i))
             } else {
                 format!("doc_{}", i)
             };
@@ -1103,7 +1106,7 @@ fn json_to_pyobject(py: Python, value: &serde_json::Value) -> PyResult<Py<PyAny>
             } else {
                 Ok(py.None())
             }
-        }
+        },
         serde_json::Value::String(s) => s.into_py_any(py),
         serde_json::Value::Array(arr) => {
             let list = PyList::new(
@@ -1113,14 +1116,14 @@ fn json_to_pyobject(py: Python, value: &serde_json::Value) -> PyResult<Py<PyAny>
                     .collect::<PyResult<Vec<_>>>()?,
             )?;
             Ok(list.unbind().into_any())
-        }
+        },
         serde_json::Value::Object(obj) => {
             let dict = PyDict::new(py);
             for (k, v) in obj {
                 dict.set_item(k, json_to_pyobject(py, v)?)?;
             }
             Ok(dict.unbind().into_any())
-        }
+        },
     }
 }
 
diff --git a/src/python_async.rs b/src/python_async.rs
index 2a47e63..9c3c013 100644
--- a/src/python_async.rs
+++ b/src/python_async.rs
@@ -31,7 +31,7 @@
 //! }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::Arc;
diff --git a/src/quantization.rs b/src/quantization.rs
index 31ac25f..781d7f9 100644
--- a/src/quantization.rs
+++ b/src/quantization.rs
@@ -17,7 +17,7 @@
 //! | SQ4 | 8x | 95-97% | 3-4x |
 //! | BQ | 32x | 85-95% | 4-8x |
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -689,7 +689,8 @@ impl ScalarQuantizer2 {
         let decoded_a = self.decode(a).unwrap();
         let decoded_b = self.decode(b).unwrap();
 
-        decoded_a.iter()
+        decoded_a
+            .iter()
             .zip(&decoded_b)
             .map(|(x, y)| (x - y).powi(2))
             .sum::<f32>()
@@ -740,9 +741,7 @@ impl TernaryQuantizer {
             let threshold = abs_values[threshold_idx];
 
             // Compute scale as mean of non-zero absolute values
-            let non_zero: Vec<f32> = abs_values.into_iter()
-                .filter(|&v| v > threshold)
-                .collect();
+            let non_zero: Vec<f32> = abs_values.into_iter().filter(|&v| v > threshold).collect();
             let scale = if non_zero.is_empty() {
                 1.0
             } else {
@@ -825,8 +824,16 @@ impl TernaryQuantizer {
             let tb = (encoded_b[byte_idx] >> bit_offset) & 0b11;
 
             // Convert to signed: 00->0, 01->+1, 10->-1
-            let va = match ta { 0b01 => 1, 0b10 => -1, _ => 0 };
-            let vb = match tb { 0b01 => 1, 0b10 => -1, _ => 0 };
+            let va = match ta {
+                0b01 => 1,
+                0b10 => -1,
+                _ => 0,
+            };
+            let vb = match tb {
+                0b01 => 1,
+                0b10 => -1,
+                _ => 0,
+            };
 
             sum += (va * vb) as f32 * self.scales[i] * self.scales[i];
         }
@@ -836,8 +843,7 @@ impl TernaryQuantizer {
 
     /// Memory footprint
     pub fn memory_usage(&self, num_vectors: usize) -> usize {
-        num_vectors * self.dimension.div_ceil(4)
-            + self.dimension * 8 // threshold + scale per dimension
+        num_vectors * self.dimension.div_ceil(4) + self.dimension * 8 // threshold + scale per dimension
     }
 }
 
@@ -894,7 +900,8 @@ impl<Q: Quantizer> AsymmetricQuantizer<Q> {
             for (id, score) in &mut candidates {
                 if let Some(full_vec) = full_vecs.get(id) {
                     // Compute exact distance
-                    *score = query.iter()
+                    *score = query
+                        .iter()
                         .zip(full_vec)
                         .map(|(a, b)| (a - b).powi(2))
                         .sum::<f32>()
@@ -920,7 +927,8 @@ impl Quantizer for ScalarQuantizer8 {
     #[inline]
     fn asymmetric_distance(&self, query: &[f32], encoded: &[u8]) -> f32 {
         let decoded = self.decode(encoded).unwrap();
-        query.iter()
+        query
+            .iter()
             .zip(&decoded)
             .map(|(a, b)| (a - b).powi(2))
             .sum::<f32>()
@@ -942,7 +950,8 @@ impl Quantizer for ScalarQuantizer4 {
     #[inline]
     fn asymmetric_distance(&self, query: &[f32], encoded: &[u8]) -> f32 {
         let decoded = self.decode(encoded).unwrap();
-        query.iter()
+        query
+            .iter()
             .zip(&decoded)
             .map(|(a, b)| (a - b).powi(2))
             .sum::<f32>()
@@ -964,7 +973,8 @@ impl Quantizer for ScalarQuantizer2 {
     #[inline]
     fn asymmetric_distance(&self, query: &[f32], encoded: &[u8]) -> f32 {
         let decoded = self.decode(encoded).unwrap();
-        query.iter()
+        query
+            .iter()
             .zip(&decoded)
             .map(|(a, b)| (a - b).powi(2))
             .sum::<f32>()
@@ -1022,7 +1032,8 @@ impl Quantizer for TernaryQuantizer {
     #[inline]
     fn asymmetric_distance(&self, query: &[f32], encoded: &[u8]) -> f32 {
         let decoded = self.decode(encoded).unwrap();
-        query.iter()
+        query
+            .iter()
             .zip(&decoded)
             .map(|(a, b)| (a - b).powi(2))
             .sum::<f32>()
@@ -1055,7 +1066,11 @@ pub struct QuantizationComparison {
 }
 
 /// Run comparison of all quantization methods
-pub fn compare_quantizers(vectors: &[Vec<f32>], _test_queries: &[Vec<f32>], _k: usize) -> Vec<QuantizationComparison> {
+pub fn compare_quantizers(
+    vectors: &[Vec<f32>],
+    _test_queries: &[Vec<f32>],
+    _k: usize,
+) -> Vec<QuantizationComparison> {
     let mut results = Vec::new();
 
     // SQ8
@@ -1124,10 +1139,11 @@ fn compute_reconstruction_mse(sq8: &ScalarQuantizer8, vectors: &[Vec<f32>]) -> f
     let mut total_mse = 0.0;
     for v in vectors {
         if let Ok(encoded) = sq8.encode(v)
-            && let Ok(decoded) = sq8.decode(&encoded) {
-                let mse: f32 = v.iter().zip(&decoded).map(|(a, b)| (a - b).powi(2)).sum();
-                total_mse += mse / v.len() as f32;
-            }
+            && let Ok(decoded) = sq8.decode(&encoded)
+        {
+            let mse: f32 = v.iter().zip(&decoded).map(|(a, b)| (a - b).powi(2)).sum();
+            total_mse += mse / v.len() as f32;
+        }
     }
     total_mse / vectors.len() as f32
 }
@@ -1136,10 +1152,11 @@ fn compute_reconstruction_mse_sq4(sq4: &ScalarQuantizer4, vectors: &[Vec<f32>])
     let mut total_mse = 0.0;
     for v in vectors {
         if let Ok(encoded) = sq4.encode(v)
-            && let Ok(decoded) = sq4.decode(&encoded) {
-                let mse: f32 = v.iter().zip(&decoded).map(|(a, b)| (a - b).powi(2)).sum();
-                total_mse += mse / v.len() as f32;
-            }
+            && let Ok(decoded) = sq4.decode(&encoded)
+        {
+            let mse: f32 = v.iter().zip(&decoded).map(|(a, b)| (a - b).powi(2)).sum();
+            total_mse += mse / v.len() as f32;
+        }
     }
     total_mse / vectors.len() as f32
 }
@@ -1148,10 +1165,11 @@ fn compute_reconstruction_mse_sq2(sq2: &ScalarQuantizer2, vectors: &[Vec<f32>])
     let mut total_mse = 0.0;
     for v in vectors {
         if let Ok(encoded) = sq2.encode(v)
-            && let Ok(decoded) = sq2.decode(&encoded) {
-                let mse: f32 = v.iter().zip(&decoded).map(|(a, b)| (a - b).powi(2)).sum();
-                total_mse += mse / v.len() as f32;
-            }
+            && let Ok(decoded) = sq2.decode(&encoded)
+        {
+            let mse: f32 = v.iter().zip(&decoded).map(|(a, b)| (a - b).powi(2)).sum();
+            total_mse += mse / v.len() as f32;
+        }
     }
     total_mse / vectors.len() as f32
 }
@@ -1160,10 +1178,11 @@ fn compute_reconstruction_mse_ternary(ternary: &TernaryQuantizer, vectors: &[Vec
     let mut total_mse = 0.0;
     for v in vectors {
         if let Ok(encoded) = ternary.encode(v)
-            && let Ok(decoded) = ternary.decode(&encoded) {
-                let mse: f32 = v.iter().zip(&decoded).map(|(a, b)| (a - b).powi(2)).sum();
-                total_mse += mse / v.len() as f32;
-            }
+            && let Ok(decoded) = ternary.decode(&encoded)
+        {
+            let mse: f32 = v.iter().zip(&decoded).map(|(a, b)| (a - b).powi(2)).sum();
+            total_mse += mse / v.len() as f32;
+        }
     }
     total_mse / vectors.len() as f32
 }
@@ -1215,7 +1234,9 @@ mod ultra_low_bit_tests {
         for (i, &val) in decoded.iter().enumerate() {
             assert!(
                 val == 0.0 || val.abs() - quantizer.scales[i].abs() < 0.001,
-                "Unexpected value {} at dim {}", val, i
+                "Unexpected value {} at dim {}",
+                val,
+                i
             );
         }
     }
@@ -1263,12 +1284,9 @@ mod ultra_low_bit_tests {
             .collect();
 
         // Search
-        let results = asymmetric.search(
-            &vectors[0],
-            &encoded_db,
-            5,
-            Some(&full_vectors),
-        ).unwrap();
+        let results = asymmetric
+            .search(&vectors[0], &encoded_db, 5, Some(&full_vectors))
+            .unwrap();
 
         assert_eq!(results.len(), 5);
         // First result should be the query itself
@@ -1286,8 +1304,10 @@ mod ultra_low_bit_tests {
 
         // Verify compression ratios increase
         for result in &comparison {
-            println!("{}: {:.1}x compression, {:.3} MSE",
-                     result.method, result.compression_ratio, result.mse);
+            println!(
+                "{}: {:.1}x compression, {:.3} MSE",
+                result.method, result.compression_ratio, result.mse
+            );
         }
     }
 }
diff --git a/src/query_analytics.rs b/src/query_analytics.rs
index d057ada..c7a4c16 100644
--- a/src/query_analytics.rs
+++ b/src/query_analytics.rs
@@ -1,9 +1,9 @@
 // Query Analytics Dashboard - Comprehensive analytics for vector search operations
 // Query patterns, performance insights, and usage analytics
 
-use std::collections::{HashMap, VecDeque, BTreeMap};
-use std::sync::atomic::{AtomicU64, Ordering};
+use std::collections::{BTreeMap, HashMap, VecDeque};
 use std::sync::RwLock;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, Instant};
 
 use serde::{Deserialize, Serialize};
@@ -37,9 +37,9 @@ impl Default for AnalyticsConfig {
             max_events: 100000,
             realtime_streaming: false,
             aggregation_intervals: vec![
-                Duration::from_secs(60),      // 1 minute
-                Duration::from_secs(3600),    // 1 hour
-                Duration::from_secs(86400),   // 1 day
+                Duration::from_secs(60),    // 1 minute
+                Duration::from_secs(3600),  // 1 hour
+                Duration::from_secs(86400), // 1 day
             ],
             log_queries: true,
             privacy_mode: false,
@@ -317,33 +317,40 @@ impl QueryAnalytics {
         match event.event_type {
             EventType::Search | EventType::BatchSearch => {
                 self.stats.search_events.fetch_add(1, Ordering::Relaxed);
-            }
+            },
             EventType::Insert | EventType::BatchInsert => {
                 self.stats.insert_events.fetch_add(1, Ordering::Relaxed);
-            }
+            },
             EventType::Update => {
                 self.stats.update_events.fetch_add(1, Ordering::Relaxed);
-            }
+            },
             EventType::Delete => {
                 self.stats.delete_events.fetch_add(1, Ordering::Relaxed);
-            }
-            _ => {}
+            },
+            _ => {},
         }
 
         // Update running average latency
         {
-            let Ok(mut avg) = self.stats.avg_latency_ms.write() else { return; };
+            let Ok(mut avg) = self.stats.avg_latency_ms.write() else {
+                return;
+            };
             let count = self.stats.total_events.load(Ordering::Relaxed) as f64;
             *avg = (*avg * (count - 1.0) + event.latency_ms) / count;
         }
 
         // Store event
         {
-            let Ok(mut events) = self.events.write() else { return; };
+            let Ok(mut events) = self.events.write() else {
+                return;
+            };
             if events.len() >= self.config.max_events {
                 events.pop_front();
             }
-            events.push_back(QueryEvent { id: event_id, ..event.clone() });
+            events.push_back(QueryEvent {
+                id: event_id,
+                ..event.clone()
+            });
         }
 
         // Update aggregates
@@ -364,18 +371,21 @@ impl QueryAnalytics {
             return false;
         }
 
-        use std::hash::{Hash, Hasher};
         use std::collections::hash_map::DefaultHasher;
+        use std::hash::{Hash, Hasher};
         let mut hasher = DefaultHasher::new();
         Instant::now().hash(&mut hasher);
         (hasher.finish() as f64 / u64::MAX as f64) < self.config.sample_rate
     }
 
     fn update_aggregates(&self, event: &QueryEvent) {
-        let Ok(mut aggregates) = self.aggregates.write() else { return; };
+        let Ok(mut aggregates) = self.aggregates.write() else {
+            return;
+        };
 
         // Overall aggregate
-        let overall = aggregates.entry("overall".to_string())
+        let overall = aggregates
+            .entry("overall".to_string())
             .or_insert_with(|| AggregateStats {
                 min_latency_ms: f64::INFINITY,
                 ..Default::default()
@@ -394,7 +404,8 @@ impl QueryAnalytics {
         overall.cache_hit_rate = overall.cache_hits as f64 / overall.count as f64;
 
         // Per-collection aggregate
-        let collection = aggregates.entry(format!("collection:{}", event.collection))
+        let collection = aggregates
+            .entry(format!("collection:{}", event.collection))
             .or_insert_with(|| AggregateStats {
                 min_latency_ms: f64::INFINITY,
                 ..Default::default()
@@ -414,38 +425,41 @@ impl QueryAnalytics {
     }
 
     fn update_patterns(&self, event: &QueryEvent) {
-        let Ok(mut patterns) = self.patterns.write() else { return; };
+        let Ok(mut patterns) = self.patterns.write() else {
+            return;
+        };
 
         // Track dimension distribution
-        *patterns.dimension_distribution
+        *patterns
+            .dimension_distribution
             .entry(event.dimensions)
             .or_insert(0) += 1;
 
         // Track k distribution
-        *patterns.k_distribution
-            .entry(event.top_k)
-            .or_insert(0) += 1;
+        *patterns.k_distribution.entry(event.top_k).or_insert(0) += 1;
 
         // Track query patterns (collection + filter count)
         let pattern_key = format!("{}:filters={}", event.collection, event.filter_count);
-        *patterns.frequent_patterns
-            .entry(pattern_key)
-            .or_insert(0) += 1;
+        *patterns.frequent_patterns.entry(pattern_key).or_insert(0) += 1;
 
         // Track temporal patterns (hourly)
         let hour = event.timestamp / 3600;
-        patterns.temporal_patterns
+        patterns
+            .temporal_patterns
             .entry(hour)
             .or_insert_with(Vec::new)
             .push(event.collection.clone());
     }
 
     fn update_timeseries(&self, event: &QueryEvent) {
-        let Ok(mut ts) = self.timeseries.write() else { return; };
+        let Ok(mut ts) = self.timeseries.write() else {
+            return;
+        };
         let bucket = event.timestamp / 60; // Minute buckets
 
         // Latency series
-        let latency_series = ts.series
+        let latency_series = ts
+            .series
             .entry("latency".to_string())
             .or_insert_with(Vec::new);
 
@@ -471,7 +485,8 @@ impl QueryAnalytics {
         }
 
         // Throughput series
-        let throughput_series = ts.series
+        let throughput_series = ts
+            .series
             .entry("throughput".to_string())
             .or_insert_with(Vec::new);
 
@@ -513,7 +528,8 @@ impl QueryAnalytics {
         let overall = aggregates.get("overall").cloned().unwrap_or_default();
 
         let uptime = self.stats.started_at.elapsed();
-        let qps = self.stats.total_events.load(Ordering::Relaxed) as f64 / uptime.as_secs_f64().max(1.0);
+        let qps =
+            self.stats.total_events.load(Ordering::Relaxed) as f64 / uptime.as_secs_f64().max(1.0);
 
         let summary = DashboardSummary {
             total_queries: overall.count,
@@ -522,13 +538,15 @@ impl QueryAnalytics {
             p99_latency_ms: overall.p99_latency_ms,
             cache_hit_rate: overall.cache_hit_rate,
             error_rate: overall.error_rate,
-            active_collections: aggregates.keys()
+            active_collections: aggregates
+                .keys()
                 .filter(|k| k.starts_with("collection:"))
                 .count(),
             uptime,
         };
 
-        let recent_queries: Vec<QuerySummary> = events.iter()
+        let recent_queries: Vec<QuerySummary> = events
+            .iter()
             .rev()
             .take(20)
             .map(|e| QuerySummary {
@@ -542,7 +560,8 @@ impl QueryAnalytics {
 
         let performance_trends = self.get_performance_trends();
 
-        let mut top_collections: Vec<CollectionStats> = aggregates.iter()
+        let mut top_collections: Vec<CollectionStats> = aggregates
+            .iter()
             .filter(|(k, _)| k.starts_with("collection:"))
             .map(|(k, stats)| CollectionStats {
                 name: k.replace("collection:", ""),
@@ -597,7 +616,9 @@ impl QueryAnalytics {
     }
 
     fn get_performance_trends(&self) -> Vec<TrendData> {
-        let Ok(ts) = self.timeseries.read() else { return vec![]; };
+        let Ok(ts) = self.timeseries.read() else {
+            return vec![];
+        };
         let mut trends = Vec::new();
 
         for (metric_name, points) in &ts.series {
@@ -681,18 +702,24 @@ impl QueryAnalytics {
 
     /// Get aggregate statistics
     pub fn get_aggregates(&self) -> HashMap<String, AggregateStats> {
-        let Ok(aggregates) = self.aggregates.read() else { return HashMap::new(); };
+        let Ok(aggregates) = self.aggregates.read() else {
+            return HashMap::new();
+        };
         aggregates.clone()
     }
 
     /// Get time series data
     pub fn get_timeseries(&self, metric: &str, last_n_minutes: usize) -> Vec<TimeSeriesPoint> {
-        let Ok(ts) = self.timeseries.read() else { return vec![]; };
+        let Ok(ts) = self.timeseries.read() else {
+            return vec![];
+        };
         let cutoff = current_timestamp() / 60 - last_n_minutes as u64;
 
-        ts.series.get(metric)
+        ts.series
+            .get(metric)
             .map(|points| {
-                points.iter()
+                points
+                    .iter()
                     .filter(|p| p.timestamp >= cutoff)
                     .cloned()
                     .collect()
@@ -702,20 +729,26 @@ impl QueryAnalytics {
 
     /// Generate a report
     pub fn generate_report(&self, config: &ReportConfig) -> Result<String> {
-        let events = self.events.read()
+        let events = self
+            .events
+            .read()
             .map_err(|_| VecStoreError::LockError("events lock poisoned".into()))?;
 
-        let filtered: Vec<_> = events.iter()
-            .filter(|e| e.timestamp >= config.time_range.start && e.timestamp <= config.time_range.end)
+        let filtered: Vec<_> = events
+            .iter()
+            .filter(|e| {
+                e.timestamp >= config.time_range.start && e.timestamp <= config.time_range.end
+            })
             .collect();
 
         match config.format {
             ReportFormat::Json => {
                 let summary: HashMap<String, serde_json::Value> = HashMap::new();
                 Ok(serde_json::to_string_pretty(&summary).unwrap_or_default())
-            }
+            },
             ReportFormat::Csv => {
-                let mut csv = String::from("timestamp,collection,latency_ms,result_count,event_type\n");
+                let mut csv =
+                    String::from("timestamp,collection,latency_ms,result_count,event_type\n");
                 for e in filtered {
                     csv.push_str(&format!(
                         "{},{},{},{},{:?}\n",
@@ -723,7 +756,7 @@ impl QueryAnalytics {
                     ));
                 }
                 Ok(csv)
-            }
+            },
             ReportFormat::Html => {
                 let html = format!(
                     r#"<!DOCTYPE html>
@@ -740,9 +773,11 @@ impl QueryAnalytics {
                     filtered.len()
                 );
                 Ok(html)
-            }
+            },
             ReportFormat::Prometheus => {
-                let aggregates = self.aggregates.read()
+                let aggregates = self
+                    .aggregates
+                    .read()
                     .map_err(|_| VecStoreError::LockError("aggregates lock poisoned".into()))?;
                 let mut output = String::new();
 
@@ -757,14 +792,12 @@ impl QueryAnalytics {
                          # HELP vecstore_cache_hit_rate Cache hit rate\n\
                          # TYPE vecstore_cache_hit_rate gauge\n\
                          vecstore_cache_hit_rate {:.4}\n",
-                        overall.count,
-                        overall.avg_latency_ms,
-                        overall.cache_hit_rate
+                        overall.count, overall.avg_latency_ms, overall.cache_hit_rate
                     ));
                 }
 
                 Ok(output)
-            }
+            },
         }
     }
 
@@ -778,18 +811,24 @@ impl QueryAnalytics {
             };
         };
 
-        let mut frequent: Vec<(String, u64)> = patterns.frequent_patterns.iter()
+        let mut frequent: Vec<(String, u64)> = patterns
+            .frequent_patterns
+            .iter()
             .map(|(k, v)| (k.clone(), *v))
             .collect();
         frequent.sort_by(|a, b| b.1.cmp(&a.1));
         frequent.truncate(10);
 
-        let mut dimensions: Vec<(usize, u64)> = patterns.dimension_distribution.iter()
+        let mut dimensions: Vec<(usize, u64)> = patterns
+            .dimension_distribution
+            .iter()
             .map(|(k, v)| (*k, *v))
             .collect();
         dimensions.sort_by(|a, b| b.1.cmp(&a.1));
 
-        let mut k_values: Vec<(usize, u64)> = patterns.k_distribution.iter()
+        let mut k_values: Vec<(usize, u64)> = patterns
+            .k_distribution
+            .iter()
             .map(|(k, v)| (*k, *v))
             .collect();
         k_values.sort_by(|a, b| b.1.cmp(&a.1));
@@ -827,22 +866,32 @@ impl QueryAnalytics {
             error_rate: overall.error_rate,
             queries_per_second: {
                 let uptime = self.stats.started_at.elapsed().as_secs_f64();
-                if uptime > 0.0 { overall.count as f64 / uptime } else { 0.0 }
+                if uptime > 0.0 {
+                    overall.count as f64 / uptime
+                } else {
+                    0.0
+                }
             },
         }
     }
 
     /// Reset analytics
     pub fn reset(&self) {
-        let Ok(mut events) = self.events.write() else { return; };
+        let Ok(mut events) = self.events.write() else {
+            return;
+        };
         events.clear();
         drop(events);
 
-        let Ok(mut aggregates) = self.aggregates.write() else { return; };
+        let Ok(mut aggregates) = self.aggregates.write() else {
+            return;
+        };
         aggregates.clear();
         drop(aggregates);
 
-        let Ok(mut patterns) = self.patterns.write() else { return; };
+        let Ok(mut patterns) = self.patterns.write() else {
+            return;
+        };
         *patterns = PatternAnalyzer {
             frequent_patterns: HashMap::new(),
             temporal_patterns: BTreeMap::new(),
@@ -857,7 +906,9 @@ impl QueryAnalytics {
         self.stats.update_events.store(0, Ordering::Relaxed);
         self.stats.delete_events.store(0, Ordering::Relaxed);
 
-        let Ok(mut avg) = self.stats.avg_latency_ms.write() else { return; };
+        let Ok(mut avg) = self.stats.avg_latency_ms.write() else {
+            return;
+        };
         *avg = 0.0;
     }
 }
@@ -892,9 +943,7 @@ pub struct LatencyHistogram {
 
 impl LatencyHistogram {
     pub fn new(bucket_boundaries: &[f64]) -> Self {
-        let buckets = bucket_boundaries.iter()
-            .map(|&b| (b, 0))
-            .collect();
+        let buckets = bucket_boundaries.iter().map(|&b| (b, 0)).collect();
 
         Self {
             buckets,
@@ -970,7 +1019,8 @@ impl QueryRecommender {
             recommendations.push(Recommendation {
                 category: RecommendationCategory::Performance,
                 title: "High Average Latency".to_string(),
-                description: "Consider optimizing index parameters or adding more replicas".to_string(),
+                description: "Consider optimizing index parameters or adding more replicas"
+                    .to_string(),
                 impact: Impact::High,
                 effort: Impact::Medium,
             });
@@ -978,33 +1028,35 @@ impl QueryRecommender {
 
         // Check dimension distribution for index optimization
         if let Some((most_common_dim, _)) = patterns.dimension_distribution.first()
-            && *most_common_dim > 512 {
-                recommendations.push(Recommendation {
-                    category: RecommendationCategory::IndexOptimization,
-                    title: "High Dimensional Vectors".to_string(),
-                    description: format!(
-                        "Most queries use {}-dimensional vectors. Consider PQ or dimension reduction.",
-                        most_common_dim
-                    ),
-                    impact: Impact::Medium,
-                    effort: Impact::High,
-                });
-            }
+            && *most_common_dim > 512
+        {
+            recommendations.push(Recommendation {
+                category: RecommendationCategory::IndexOptimization,
+                title: "High Dimensional Vectors".to_string(),
+                description: format!(
+                    "Most queries use {}-dimensional vectors. Consider PQ or dimension reduction.",
+                    most_common_dim
+                ),
+                impact: Impact::Medium,
+                effort: Impact::High,
+            });
+        }
 
         // Check k distribution
         if let Some((most_common_k, _)) = patterns.k_distribution.first()
-            && *most_common_k > 100 {
-                recommendations.push(Recommendation {
-                    category: RecommendationCategory::QueryOptimization,
-                    title: "Large Top-K Values".to_string(),
-                    description: format!(
-                        "Many queries request top-{}. Consider pagination instead.",
-                        most_common_k
-                    ),
-                    impact: Impact::Medium,
-                    effort: Impact::Low,
-                });
-            }
+            && *most_common_k > 100
+        {
+            recommendations.push(Recommendation {
+                category: RecommendationCategory::QueryOptimization,
+                title: "Large Top-K Values".to_string(),
+                description: format!(
+                    "Many queries request top-{}. Consider pagination instead.",
+                    most_common_k
+                ),
+                impact: Impact::Medium,
+                effort: Impact::Low,
+            });
+        }
 
         recommendations
     }
@@ -1099,9 +1151,7 @@ mod tests {
 
     #[test]
     fn test_analytics_creation() {
-        let analytics = QueryAnalyticsBuilder::new()
-            .sample_rate(1.0)
-            .build();
+        let analytics = QueryAnalyticsBuilder::new().sample_rate(1.0).build();
 
         let dashboard = analytics.get_dashboard();
         assert_eq!(dashboard.summary.total_queries, 0);
@@ -1109,9 +1159,7 @@ mod tests {
 
     #[test]
     fn test_record_event() {
-        let analytics = QueryAnalyticsBuilder::new()
-            .sample_rate(1.0)
-            .build();
+        let analytics = QueryAnalyticsBuilder::new().sample_rate(1.0).build();
 
         let event = QueryEvent {
             id: 0,
@@ -1137,9 +1185,7 @@ mod tests {
 
     #[test]
     fn test_timeseries() {
-        let analytics = QueryAnalyticsBuilder::new()
-            .sample_rate(1.0)
-            .build();
+        let analytics = QueryAnalyticsBuilder::new().sample_rate(1.0).build();
 
         for i in 0..10 {
             let event = QueryEvent {
@@ -1166,9 +1212,7 @@ mod tests {
 
     #[test]
     fn test_report_generation() {
-        let analytics = QueryAnalyticsBuilder::new()
-            .sample_rate(1.0)
-            .build();
+        let analytics = QueryAnalyticsBuilder::new().sample_rate(1.0).build();
 
         let config = ReportConfig {
             time_range: TimeRange {
diff --git a/src/query_explain.rs b/src/query_explain.rs
index 4c18d8d..9785cb6 100644
--- a/src/query_explain.rs
+++ b/src/query_explain.rs
@@ -81,47 +81,27 @@ pub enum PlanNodeType {
     /// Root query node
     Query,
     /// Vector similarity search
-    VectorScan {
-        index_type: String,
-        metric: String,
-    },
+    VectorScan { index_type: String, metric: String },
     /// Metadata filter
-    Filter {
-        expression: String,
-    },
+    Filter { expression: String },
     /// Hybrid search fusion
-    Fusion {
-        strategy: String,
-    },
+    Fusion { strategy: String },
     /// Reranking stage
-    Rerank {
-        method: String,
-    },
+    Rerank { method: String },
     /// Result limit/offset
-    Limit {
-        limit: usize,
-        offset: usize,
-    },
+    Limit { limit: usize, offset: usize },
     /// Aggregation
-    Aggregate {
-        function: String,
-    },
+    Aggregate { function: String },
     /// Cache lookup
     CacheLookup,
     /// Parallel execution
-    Parallel {
-        workers: usize,
-    },
+    Parallel { workers: usize },
     /// Index scan
-    IndexScan {
-        index_name: String,
-    },
+    IndexScan { index_name: String },
     /// Sequential scan (fallback)
     SeqScan,
     /// Sort operation
-    Sort {
-        keys: Vec<String>,
-    },
+    Sort { keys: Vec<String> },
 }
 
 /// Execution plan node
@@ -181,9 +161,7 @@ impl PlanNode {
     /// Total time including children
     pub fn total_time_ms(&self) -> f64 {
         let self_time = self.actual_time_ms.unwrap_or(0.0);
-        let children_time: f64 = self.children.iter()
-            .map(|c| c.total_time_ms())
-            .sum();
+        let children_time: f64 = self.children.iter().map(|c| c.total_time_ms()).sum();
         self_time + children_time
     }
 
@@ -196,26 +174,19 @@ impl PlanNode {
         // Node type and basic info
         let node_name = match &self.node_type {
             PlanNodeType::Query => "Query".to_string(),
-            PlanNodeType::VectorScan { index_type, metric } =>
-                format!("Vector Scan ({}, {})", index_type, metric),
-            PlanNodeType::Filter { expression } =>
-                format!("Filter ({})", expression),
-            PlanNodeType::Fusion { strategy } =>
-                format!("Fusion ({})", strategy),
-            PlanNodeType::Rerank { method } =>
-                format!("Rerank ({})", method),
-            PlanNodeType::Limit { limit, offset } =>
-                format!("Limit {} Offset {}", limit, offset),
-            PlanNodeType::Aggregate { function } =>
-                format!("Aggregate ({})", function),
+            PlanNodeType::VectorScan { index_type, metric } => {
+                format!("Vector Scan ({}, {})", index_type, metric)
+            },
+            PlanNodeType::Filter { expression } => format!("Filter ({})", expression),
+            PlanNodeType::Fusion { strategy } => format!("Fusion ({})", strategy),
+            PlanNodeType::Rerank { method } => format!("Rerank ({})", method),
+            PlanNodeType::Limit { limit, offset } => format!("Limit {} Offset {}", limit, offset),
+            PlanNodeType::Aggregate { function } => format!("Aggregate ({})", function),
             PlanNodeType::CacheLookup => "Cache Lookup".to_string(),
-            PlanNodeType::Parallel { workers } =>
-                format!("Parallel ({} workers)", workers),
-            PlanNodeType::IndexScan { index_name } =>
-                format!("Index Scan ({})", index_name),
+            PlanNodeType::Parallel { workers } => format!("Parallel ({} workers)", workers),
+            PlanNodeType::IndexScan { index_name } => format!("Index Scan ({})", index_name),
             PlanNodeType::SeqScan => "Sequential Scan".to_string(),
-            PlanNodeType::Sort { keys } =>
-                format!("Sort ({})", keys.join(", ")),
+            PlanNodeType::Sort { keys } => format!("Sort ({})", keys.join(", ")),
         };
 
         output.push_str(&format!("{}{}{}", prefix, arrow, node_name));
@@ -273,7 +244,8 @@ impl PlanNode {
     pub fn format_html(&self) -> String {
         let mut html = String::new();
 
-        html.push_str(r#"<!DOCTYPE html>
+        html.push_str(
+            r#"<!DOCTYPE html>
 <html>
 <head>
 <style>
@@ -292,7 +264,8 @@ h1 { color: #569cd6; }
 </head>
 <body>
 <h1>Query Execution Plan</h1>
-"#);
+"#,
+        );
 
         html.push_str(&self.format_html_node(100.0));
 
@@ -305,26 +278,19 @@ h1 { color: #569cd6; }
 
         let node_name = match &self.node_type {
             PlanNodeType::Query => "Query".to_string(),
-            PlanNodeType::VectorScan { index_type, metric } =>
-                format!("Vector Scan ({}, {})", index_type, metric),
-            PlanNodeType::Filter { expression } =>
-                format!("Filter: {}", expression),
-            PlanNodeType::Fusion { strategy } =>
-                format!("Fusion: {}", strategy),
-            PlanNodeType::Rerank { method } =>
-                format!("Rerank: {}", method),
-            PlanNodeType::Limit { limit, offset } =>
-                format!("Limit {} Offset {}", limit, offset),
-            PlanNodeType::Aggregate { function } =>
-                format!("Aggregate: {}", function),
+            PlanNodeType::VectorScan { index_type, metric } => {
+                format!("Vector Scan ({}, {})", index_type, metric)
+            },
+            PlanNodeType::Filter { expression } => format!("Filter: {}", expression),
+            PlanNodeType::Fusion { strategy } => format!("Fusion: {}", strategy),
+            PlanNodeType::Rerank { method } => format!("Rerank: {}", method),
+            PlanNodeType::Limit { limit, offset } => format!("Limit {} Offset {}", limit, offset),
+            PlanNodeType::Aggregate { function } => format!("Aggregate: {}", function),
             PlanNodeType::CacheLookup => "Cache Lookup".to_string(),
-            PlanNodeType::Parallel { workers } =>
-                format!("Parallel ({} workers)", workers),
-            PlanNodeType::IndexScan { index_name } =>
-                format!("Index Scan: {}", index_name),
+            PlanNodeType::Parallel { workers } => format!("Parallel ({} workers)", workers),
+            PlanNodeType::IndexScan { index_name } => format!("Index Scan: {}", index_name),
             PlanNodeType::SeqScan => "Sequential Scan".to_string(),
-            PlanNodeType::Sort { keys } =>
-                format!("Sort: {}", keys.join(", ")),
+            PlanNodeType::Sort { keys } => format!("Sort: {}", keys.join(", ")),
         };
 
         let time_pct = if parent_time > 0.0 {
@@ -335,17 +301,29 @@ h1 { color: #569cd6; }
 
         html.push_str("<div class=\"node\">");
         html.push_str(&format!("<span class=\"node-type\">{}</span>", node_name));
-        html.push_str(&format!(" <span class=\"cost\">cost={:.2}</span>", self.estimated_cost));
+        html.push_str(&format!(
+            " <span class=\"cost\">cost={:.2}</span>",
+            self.estimated_cost
+        ));
 
         if let Some(actual) = self.actual_rows {
-            html.push_str(&format!(" <span class=\"rows\">rows={}/{}</span>", actual, self.estimated_rows));
+            html.push_str(&format!(
+                " <span class=\"rows\">rows={}/{}</span>",
+                actual, self.estimated_rows
+            ));
         } else {
-            html.push_str(&format!(" <span class=\"rows\">rows={}</span>", self.estimated_rows));
+            html.push_str(&format!(
+                " <span class=\"rows\">rows={}</span>",
+                self.estimated_rows
+            ));
         }
 
         if let Some(time) = self.actual_time_ms {
             html.push_str(&format!(" <span class=\"time\">[{:.3} ms]</span>", time));
-            html.push_str(&format!("<div class=\"bar\" style=\"width: {}%;\"></div>", time_pct));
+            html.push_str(&format!(
+                "<div class=\"bar\" style=\"width: {}%;\"></div>",
+                time_pct
+            ));
         }
 
         for (key, value) in &self.properties {
@@ -353,7 +331,10 @@ h1 { color: #569cd6; }
         }
 
         for warning in &self.warnings {
-            html.push_str(&format!("<div class=\"warning\">WARNING: {}</div>", warning));
+            html.push_str(&format!(
+                "<div class=\"warning\">WARNING: {}</div>",
+                warning
+            ));
         }
 
         if !self.children.is_empty() {
@@ -382,7 +363,12 @@ h1 { color: #569cd6; }
         dot
     }
 
-    fn format_dot_node(&self, dot: &mut String, counter: &mut usize, parent: Option<usize>) -> usize {
+    fn format_dot_node(
+        &self,
+        dot: &mut String,
+        counter: &mut usize,
+        parent: Option<usize>,
+    ) -> usize {
         let id = *counter;
         *counter += 1;
 
@@ -392,7 +378,7 @@ h1 { color: #569cd6; }
             PlanNodeType::Filter { expression } => format!("Filter\\n{}", expression),
             PlanNodeType::Fusion { strategy } => format!("Fusion\\n{}", strategy),
             PlanNodeType::Rerank { method } => format!("Rerank\\n{}", method),
-            PlanNodeType::Limit { limit, .. } => format!("Limit {}",limit),
+            PlanNodeType::Limit { limit, .. } => format!("Limit {}", limit),
             _ => format!("{:?}", self.node_type),
         };
 
@@ -517,15 +503,25 @@ impl ExplainResult {
             output.push_str(&"-".repeat(60));
             output.push('\n');
             output.push_str(&format!("Total time: {:.3} ms\n", self.stats.total_time_ms));
-            output.push_str(&format!("  Planning: {:.3} ms\n", self.stats.planning_time_ms));
-            output.push_str(&format!("  Execution: {:.3} ms\n", self.stats.execution_time_ms));
-            output.push_str(&format!("Rows: {} examined, {} returned\n",
-                self.stats.rows_examined, self.stats.rows_returned));
+            output.push_str(&format!(
+                "  Planning: {:.3} ms\n",
+                self.stats.planning_time_ms
+            ));
+            output.push_str(&format!(
+                "  Execution: {:.3} ms\n",
+                self.stats.execution_time_ms
+            ));
+            output.push_str(&format!(
+                "Rows: {} examined, {} returned\n",
+                self.stats.rows_examined, self.stats.rows_returned
+            ));
         }
 
         if options.buffers {
-            output.push_str(&format!("Cache: {} hits, {} misses\n",
-                self.stats.cache_hits, self.stats.cache_misses));
+            output.push_str(&format!(
+                "Cache: {} hits, {} misses\n",
+                self.stats.cache_hits, self.stats.cache_misses
+            ));
             output.push_str(&format!("Memory: {} bytes\n", self.stats.memory_bytes));
             output.push_str(&format!("Disk reads: {}\n", self.stats.disk_reads));
         }
@@ -535,9 +531,16 @@ impl ExplainResult {
             output.push_str(&"-".repeat(60));
             output.push('\n');
             for (i, suggestion) in self.suggestions.iter().enumerate() {
-                output.push_str(&format!("{}. [{:?}] {}\n",
-                    i + 1, suggestion.suggestion_type, suggestion.description));
-                output.push_str(&format!("   Improvement: {}\n", suggestion.estimated_improvement));
+                output.push_str(&format!(
+                    "{}. [{:?}] {}\n",
+                    i + 1,
+                    suggestion.suggestion_type,
+                    suggestion.description
+                ));
+                output.push_str(&format!(
+                    "   Improvement: {}\n",
+                    suggestion.estimated_improvement
+                ));
                 output.push_str(&format!("   Action: {}\n", suggestion.action));
             }
         }
@@ -566,7 +569,8 @@ impl ExplainResult {
 
         // Insert stats before closing body
         if options.timing {
-            let stats_html = format!(r#"
+            let stats_html = format!(
+                r#"
 <div style="margin-top: 20px; padding: 15px; background: #252526; border: 1px solid #569cd6;">
 <h2 style="color: #569cd6;">Execution Statistics</h2>
 <table style="width: 100%;">
@@ -652,7 +656,10 @@ impl QueryExplainer {
         root.actual_rows = Some(k);
 
         // Add limit node
-        let mut limit_node = PlanNode::new(PlanNodeType::Limit { limit: k, offset: 0 });
+        let mut limit_node = PlanNode::new(PlanNodeType::Limit {
+            limit: k,
+            offset: 0,
+        });
         limit_node.estimated_rows = k;
         limit_node.actual_rows = Some(k);
         limit_node.estimated_cost = 0.1;
@@ -689,7 +696,8 @@ impl QueryExplainer {
             });
 
             // Estimate selectivity
-            let selectivity = self.selectivity_history
+            let selectivity = self
+                .selectivity_history
                 .get(filter_expr)
                 .copied()
                 .unwrap_or(0.1);
@@ -803,13 +811,19 @@ impl QueryExplainer {
         text_node.estimated_rows = k * 2;
         text_node.estimated_cost = 3.0;
         text_node.actual_time_ms = Some(2.0);
-        text_node.set_property("query_terms", &query_text.split_whitespace().count().to_string());
+        text_node.set_property(
+            "query_terms",
+            &query_text.split_whitespace().count().to_string(),
+        );
 
         fusion_node.add_child(vector_node);
         fusion_node.add_child(text_node);
 
         // Limit
-        let mut limit_node = PlanNode::new(PlanNodeType::Limit { limit: k, offset: 0 });
+        let mut limit_node = PlanNode::new(PlanNodeType::Limit {
+            limit: k,
+            offset: 0,
+        });
         limit_node.estimated_rows = k;
         limit_node.estimated_cost = 0.1;
         limit_node.actual_time_ms = Some(0.01);
@@ -855,12 +869,7 @@ mod tests {
         let explainer = QueryExplainer::new();
         let query = vec![0.1f32; 128];
 
-        let result = explainer.explain_search(
-            &query,
-            10,
-            None,
-            &ExplainOptions::default()
-        );
+        let result = explainer.explain_search(&query, 10, None, &ExplainOptions::default());
 
         assert!(result.stats.total_time_ms > 0.0);
         assert_eq!(result.stats.rows_returned, 10);
@@ -875,7 +884,7 @@ mod tests {
             &query,
             10,
             Some("category = 'test'"),
-            &ExplainOptions::default()
+            &ExplainOptions::default(),
         );
 
         let text = result.format(&ExplainOptions::default());
@@ -919,12 +928,7 @@ mod tests {
         let explainer = QueryExplainer::new();
         let query = vec![0.1f32; 128];
 
-        let result = explainer.explain_hybrid(
-            &query,
-            "test query",
-            10,
-            &ExplainOptions::default()
-        );
+        let result = explainer.explain_hybrid(&query, "test query", 10, &ExplainOptions::default());
 
         let text = result.format(&ExplainOptions::default());
         assert!(text.contains("Fusion"));
diff --git a/src/query_router.rs b/src/query_router.rs
index 95536d4..6c8a574 100644
--- a/src/query_router.rs
+++ b/src/query_router.rs
@@ -293,9 +293,10 @@ impl QueryRouter {
         let node_id = node.id.clone();
         let node = Arc::new(node);
 
-        let mut nodes_guard = self.nodes.write().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire nodes write lock".into())
-        })?;
+        let mut nodes_guard = self
+            .nodes
+            .write()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire nodes write lock".into()))?;
         nodes_guard.insert(node_id.clone(), node);
         drop(nodes_guard);
 
@@ -309,9 +310,10 @@ impl QueryRouter {
 
     /// Deregister a replica node
     pub fn deregister_node(&self, node_id: &str) -> Result<()> {
-        let mut nodes_guard = self.nodes.write().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire nodes write lock".into())
-        })?;
+        let mut nodes_guard = self
+            .nodes
+            .write()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire nodes write lock".into()))?;
         nodes_guard.remove(node_id);
         drop(nodes_guard);
 
@@ -326,10 +328,12 @@ impl QueryRouter {
     pub fn route(&self, query: &QueryCharacteristics) -> Result<RoutingDecision> {
         self.metrics.requests_total.fetch_add(1, Ordering::Relaxed);
 
-        let nodes = self.nodes.read().map_err(|_| {
-            VecStoreError::Internal("Failed to acquire nodes read lock".into())
-        })?;
-        let available: Vec<_> = nodes.values()
+        let nodes = self
+            .nodes
+            .read()
+            .map_err(|_| VecStoreError::Internal("Failed to acquire nodes read lock".into()))?;
+        let available: Vec<_> = nodes
+            .values()
             .filter(|n| self.is_available(n))
             .cloned()
             .collect();
@@ -361,8 +365,8 @@ impl QueryRouter {
 
         let estimated_latency = if let Ok(state) = selected.state.read() {
             if !state.latencies.is_empty() {
-                let avg: Duration = state.latencies.iter().sum::<Duration>()
-                    / state.latencies.len() as u32;
+                let avg: Duration =
+                    state.latencies.iter().sum::<Duration>() / state.latencies.len() as u32;
                 Some(avg)
             } else {
                 None
@@ -381,15 +385,18 @@ impl QueryRouter {
     }
 
     fn is_available(&self, node: &ReplicaNode) -> bool {
-        let Ok(state) = node.state.read() else { return false; };
+        let Ok(state) = node.state.read() else {
+            return false;
+        };
 
         // Check circuit breaker
         if state.circuit_state == CircuitState::Open
             && let Some(opened_at) = state.circuit_opened_at
-                && opened_at.elapsed() < self.config.circuit_breaker_timeout {
-                    return false;
-                }
-                // Allow half-open state
+            && opened_at.elapsed() < self.config.circuit_breaker_timeout
+        {
+            return false;
+        }
+        // Allow half-open state
 
         state.health != HealthStatus::Unhealthy
     }
@@ -399,7 +406,10 @@ impl QueryRouter {
         (nodes[idx].clone(), RoutingReason::LoadBalance)
     }
 
-    fn weighted_round_robin(&self, nodes: &[Arc<ReplicaNode>]) -> (Arc<ReplicaNode>, RoutingReason) {
+    fn weighted_round_robin(
+        &self,
+        nodes: &[Arc<ReplicaNode>],
+    ) -> (Arc<ReplicaNode>, RoutingReason) {
         let total_weight: u32 = nodes.iter().map(|n| n.weight).sum();
         let counter = self.rr_counter.fetch_add(1, Ordering::Relaxed);
         let target = (counter as u32) % total_weight;
@@ -416,9 +426,13 @@ impl QueryRouter {
     }
 
     fn least_connections(&self, nodes: &[Arc<ReplicaNode>]) -> (Arc<ReplicaNode>, RoutingReason) {
-        let selected = nodes.iter()
+        let selected = nodes
+            .iter()
             .min_by_key(|n| {
-                n.state.read().map(|s| s.active_connections).unwrap_or(u32::MAX)
+                n.state
+                    .read()
+                    .map(|s| s.active_connections)
+                    .unwrap_or(u32::MAX)
             })
             .unwrap();
 
@@ -426,7 +440,8 @@ impl QueryRouter {
     }
 
     fn least_latency(&self, nodes: &[Arc<ReplicaNode>]) -> (Arc<ReplicaNode>, RoutingReason) {
-        let selected = nodes.iter()
+        let selected = nodes
+            .iter()
             .min_by(|a, b| {
                 let a_lat = self.avg_latency(a);
                 let b_lat = self.avg_latency(b);
@@ -438,7 +453,9 @@ impl QueryRouter {
     }
 
     fn avg_latency(&self, node: &ReplicaNode) -> Duration {
-        let Ok(state) = node.state.read() else { return Duration::from_millis(100); };
+        let Ok(state) = node.state.read() else {
+            return Duration::from_millis(100);
+        };
         if state.latencies.is_empty() {
             Duration::from_millis(100) // Default estimate
         } else {
@@ -456,16 +473,20 @@ impl QueryRouter {
         (nodes[idx].clone(), RoutingReason::Random)
     }
 
-    fn consistent_hash(&self, nodes: &[Arc<ReplicaNode>], query: &QueryCharacteristics)
-        -> (Arc<ReplicaNode>, RoutingReason)
-    {
+    fn consistent_hash(
+        &self,
+        nodes: &[Arc<ReplicaNode>],
+        query: &QueryCharacteristics,
+    ) -> (Arc<ReplicaNode>, RoutingReason) {
         // Check for cache affinity via consistent hash (Rust 1.92 if-let chain)
         if let Some(hash) = query.query_hash
             && let Ok(ring) = self.hash_ring.read()
             && let Some(node_id) = ring.get_node(hash)
             && let Some(node) = nodes.iter().find(|n| n.id == node_id)
         {
-            self.metrics.cache_affinity_hits.fetch_add(1, Ordering::Relaxed);
+            self.metrics
+                .cache_affinity_hits
+                .fetch_add(1, Ordering::Relaxed);
             return (node.clone(), RoutingReason::CacheAffinity);
         }
 
@@ -473,11 +494,14 @@ impl QueryRouter {
         self.round_robin(nodes)
     }
 
-    fn adaptive(&self, nodes: &[Arc<ReplicaNode>], query: &QueryCharacteristics)
-        -> (Arc<ReplicaNode>, RoutingReason)
-    {
+    fn adaptive(
+        &self,
+        nodes: &[Arc<ReplicaNode>],
+        query: &QueryCharacteristics,
+    ) -> (Arc<ReplicaNode>, RoutingReason) {
         // Score each node based on multiple factors
-        let mut scores: Vec<(Arc<ReplicaNode>, f64)> = nodes.iter()
+        let mut scores: Vec<(Arc<ReplicaNode>, f64)> = nodes
+            .iter()
             .map(|n| {
                 let score = self.compute_adaptive_score(n, query);
                 (n.clone(), score)
@@ -490,7 +514,9 @@ impl QueryRouter {
     }
 
     fn compute_adaptive_score(&self, node: &ReplicaNode, query: &QueryCharacteristics) -> f64 {
-        let Ok(state) = node.state.read() else { return 0.0; };
+        let Ok(state) = node.state.read() else {
+            return 0.0;
+        };
         let mut score = 100.0;
 
         // Penalize based on connections (0-30 points)
@@ -499,8 +525,8 @@ impl QueryRouter {
 
         // Penalize based on latency (0-30 points)
         if !state.latencies.is_empty() {
-            let avg_ms = state.latencies.iter()
-                .sum::<Duration>().as_millis() as f64 / state.latencies.len() as f64;
+            let avg_ms = state.latencies.iter().sum::<Duration>().as_millis() as f64
+                / state.latencies.len() as f64;
             score -= (avg_ms / 100.0).min(30.0);
         }
 
@@ -522,9 +548,10 @@ impl QueryRouter {
         // Bonus for locality
         if self.config.locality_aware_routing
             && let Some(ref local_zone) = self.config.local_zone
-                && &node.zone == local_zone {
-                    score += 10.0;
-                }
+            && &node.zone == local_zone
+        {
+            score += 10.0;
+        }
 
         score.max(0.0)
     }
@@ -543,20 +570,30 @@ impl QueryRouter {
             }
 
             // Try to find a local node with acceptable load
-            let local_nodes: Vec<_> = all_nodes.iter()
-                .filter(|n| &n.zone == local_zone)
-                .collect();
+            let local_nodes: Vec<_> = all_nodes.iter().filter(|n| &n.zone == local_zone).collect();
 
             if !local_nodes.is_empty() {
                 // Pick the least loaded local node
-                let local = local_nodes.iter()
+                let local = local_nodes
+                    .iter()
                     .min_by_key(|n| {
-                        n.state.read().map(|s| s.active_connections).unwrap_or(u32::MAX)
+                        n.state
+                            .read()
+                            .map(|s| s.active_connections)
+                            .unwrap_or(u32::MAX)
                     })
                     .unwrap();
 
-                let local_load = local.state.read().map(|s| s.active_connections).unwrap_or(u32::MAX);
-                let selected_load = selected.state.read().map(|s| s.active_connections).unwrap_or(0);
+                let local_load = local
+                    .state
+                    .read()
+                    .map(|s| s.active_connections)
+                    .unwrap_or(u32::MAX);
+                let selected_load = selected
+                    .state
+                    .read()
+                    .map(|s| s.active_connections)
+                    .unwrap_or(0);
 
                 // Only prefer local if load difference is within 20%
                 if local_load as f64 <= selected_load as f64 * 1.2 {
@@ -569,8 +606,13 @@ impl QueryRouter {
         (selected, reason)
     }
 
-    fn build_fallbacks(&self, selected: &ReplicaNode, all_nodes: &[Arc<ReplicaNode>]) -> Vec<String> {
-        let mut fallbacks: Vec<_> = all_nodes.iter()
+    fn build_fallbacks(
+        &self,
+        selected: &ReplicaNode,
+        all_nodes: &[Arc<ReplicaNode>],
+    ) -> Vec<String> {
+        let mut fallbacks: Vec<_> = all_nodes
+            .iter()
             .filter(|n| n.id != selected.id)
             .filter_map(|n| {
                 let state = n.state.read().ok()?;
@@ -585,9 +627,13 @@ impl QueryRouter {
 
     /// Record request result (for metrics and circuit breaker)
     pub fn record_result(&self, node_id: &str, success: bool, latency: Duration) {
-        let Ok(nodes) = self.nodes.read() else { return; };
+        let Ok(nodes) = self.nodes.read() else {
+            return;
+        };
         if let Some(node) = nodes.get(node_id) {
-            let Ok(mut state) = node.state.write() else { return; };
+            let Ok(mut state) = node.state.write() else {
+                return;
+            };
 
             // Update latency window
             state.latencies.push_back(latency);
@@ -596,7 +642,9 @@ impl QueryRouter {
             }
 
             if success {
-                self.metrics.requests_succeeded.fetch_add(1, Ordering::Relaxed);
+                self.metrics
+                    .requests_succeeded
+                    .fetch_add(1, Ordering::Relaxed);
                 state.recent_errors = 0;
 
                 // Reset circuit breaker on success in half-open state
@@ -610,11 +658,12 @@ impl QueryRouter {
 
                 // Check circuit breaker threshold
                 if state.recent_errors >= self.config.circuit_breaker_threshold
-                    && state.circuit_state == CircuitState::Closed {
-                        state.circuit_state = CircuitState::Open;
-                        state.circuit_opened_at = Some(Instant::now());
-                        self.metrics.circuit_breaks.fetch_add(1, Ordering::Relaxed);
-                    }
+                    && state.circuit_state == CircuitState::Closed
+                {
+                    state.circuit_state = CircuitState::Open;
+                    state.circuit_opened_at = Some(Instant::now());
+                    self.metrics.circuit_breaks.fetch_add(1, Ordering::Relaxed);
+                }
             }
 
             state.active_connections = state.active_connections.saturating_sub(1);
@@ -623,18 +672,26 @@ impl QueryRouter {
 
     /// Increment active connections for a node
     pub fn increment_connections(&self, node_id: &str) {
-        let Ok(nodes) = self.nodes.read() else { return; };
+        let Ok(nodes) = self.nodes.read() else {
+            return;
+        };
         if let Some(node) = nodes.get(node_id) {
-            let Ok(mut state) = node.state.write() else { return; };
+            let Ok(mut state) = node.state.write() else {
+                return;
+            };
             state.active_connections += 1;
         }
     }
 
     /// Update node health status
     pub fn update_health(&self, node_id: &str, health: HealthStatus) {
-        let Ok(nodes) = self.nodes.read() else { return; };
+        let Ok(nodes) = self.nodes.read() else {
+            return;
+        };
         if let Some(node) = nodes.get(node_id) {
-            let Ok(mut state) = node.state.write() else { return; };
+            let Ok(mut state) = node.state.write() else {
+                return;
+            };
             state.health = health;
             state.last_health_check = Instant::now();
         }
@@ -643,7 +700,8 @@ impl QueryRouter {
     /// Get router statistics
     pub fn get_stats(&self) -> RouterStats {
         let node_stats: Vec<NodeStats> = if let Ok(nodes) = self.nodes.read() {
-            nodes.values()
+            nodes
+                .values()
                 .filter_map(|n| {
                     let state = n.state.read().ok()?;
                     Some(NodeStats {
@@ -675,12 +733,20 @@ impl QueryRouter {
             locality_hit_rate: {
                 let total = self.metrics.requests_total.load(Ordering::Relaxed);
                 let hits = self.metrics.locality_hits.load(Ordering::Relaxed);
-                if total > 0 { hits as f64 / total as f64 } else { 0.0 }
+                if total > 0 {
+                    hits as f64 / total as f64
+                } else {
+                    0.0
+                }
             },
             cache_affinity_hit_rate: {
                 let total = self.metrics.requests_total.load(Ordering::Relaxed);
                 let hits = self.metrics.cache_affinity_hits.load(Ordering::Relaxed);
-                if total > 0 { hits as f64 / total as f64 } else { 0.0 }
+                if total > 0 {
+                    hits as f64 / total as f64
+                } else {
+                    0.0
+                }
             },
             node_stats,
         }
@@ -689,7 +755,13 @@ impl QueryRouter {
 
 impl ReplicaNode {
     /// Create a new replica node
-    pub fn new(id: String, address: String, zone: String, weight: u32, capabilities: NodeCapabilities) -> Self {
+    pub fn new(
+        id: String,
+        address: String,
+        zone: String,
+        weight: u32,
+        capabilities: NodeCapabilities,
+    ) -> Self {
         Self {
             id,
             address,
@@ -780,7 +852,9 @@ impl RetryHandler {
 
     /// Check if an error is retryable
     pub fn is_retryable(&self, error: &str) -> bool {
-        self.config.retryable_errors.iter()
+        self.config
+            .retryable_errors
+            .iter()
             .any(|e| error.to_lowercase().contains(&e.to_lowercase()))
     }
 
@@ -848,7 +922,8 @@ fn rand_u16() -> u16 {
     (SystemTime::now()
         .duration_since(SystemTime::UNIX_EPOCH)
         .unwrap()
-        .as_nanos() & 0xFFFF) as u16
+        .as_nanos()
+        & 0xFFFF) as u16
 }
 
 #[cfg(test)]
@@ -878,9 +953,15 @@ mod tests {
             ..Default::default()
         });
 
-        router.register_node(create_test_node("node1", "us-east-1", 1)).unwrap();
-        router.register_node(create_test_node("node2", "us-east-1", 1)).unwrap();
-        router.register_node(create_test_node("node3", "us-east-1", 1)).unwrap();
+        router
+            .register_node(create_test_node("node1", "us-east-1", 1))
+            .unwrap();
+        router
+            .register_node(create_test_node("node2", "us-east-1", 1))
+            .unwrap();
+        router
+            .register_node(create_test_node("node3", "us-east-1", 1))
+            .unwrap();
 
         let query = QueryCharacteristics {
             dimensions: 768,
@@ -912,9 +993,15 @@ mod tests {
             ..Default::default()
         });
 
-        router.register_node(create_test_node("node1", "us-west-1", 1)).unwrap();
-        router.register_node(create_test_node("node2", "us-east-1", 1)).unwrap();
-        router.register_node(create_test_node("node3", "eu-west-1", 1)).unwrap();
+        router
+            .register_node(create_test_node("node1", "us-west-1", 1))
+            .unwrap();
+        router
+            .register_node(create_test_node("node2", "us-east-1", 1))
+            .unwrap();
+        router
+            .register_node(create_test_node("node3", "eu-west-1", 1))
+            .unwrap();
 
         let query = QueryCharacteristics {
             dimensions: 768,
@@ -938,8 +1025,12 @@ mod tests {
             ..Default::default()
         });
 
-        router.register_node(create_test_node("node1", "us-east-1", 1)).unwrap();
-        router.register_node(create_test_node("node2", "us-east-1", 1)).unwrap();
+        router
+            .register_node(create_test_node("node1", "us-east-1", 1))
+            .unwrap();
+        router
+            .register_node(create_test_node("node2", "us-east-1", 1))
+            .unwrap();
 
         // Simulate failures
         for _ in 0..5 {
diff --git a/src/rabitq.rs b/src/rabitq.rs
index ecbd3d7..91a5399 100644
--- a/src/rabitq.rs
+++ b/src/rabitq.rs
@@ -35,12 +35,12 @@
 //! let results = quantizer.search(&query, &codes, 10)?;
 //! ```
 
-use std::collections::HashMap;
-use serde::{Deserialize, Serialize};
 use rand::Rng;
 use rand::SeedableRng;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 /// Configuration for RaBitQ quantization
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -67,11 +67,17 @@ pub const DEFAULT_NUM_SUBVECTORS: usize = 1;
 pub const DEFAULT_RERANK_FACTOR: usize = 4;
 
 #[inline]
-const fn default_num_subvectors() -> usize { DEFAULT_NUM_SUBVECTORS }
+const fn default_num_subvectors() -> usize {
+    DEFAULT_NUM_SUBVECTORS
+}
 #[inline]
-const fn default_true() -> bool { true }
+const fn default_true() -> bool {
+    true
+}
 #[inline]
-const fn default_rerank_factor() -> usize { DEFAULT_RERANK_FACTOR }
+const fn default_rerank_factor() -> usize {
+    DEFAULT_RERANK_FACTOR
+}
 
 impl RaBitQConfig {
     /// Create a new configuration
@@ -173,7 +179,8 @@ impl BinaryCode {
     /// Hamming distance to another code
     #[inline]
     pub fn hamming_distance(&self, other: &BinaryCode) -> u32 {
-        self.bits.iter()
+        self.bits
+            .iter()
             .zip(other.bits.iter())
             .map(|(a, b)| (a ^ b).count_ones())
             .sum()
@@ -222,7 +229,9 @@ impl RaBitQ {
     /// Train the quantizer on sample vectors
     pub fn train(&mut self, vectors: &[Vec<f32>]) -> Result<()> {
         if vectors.is_empty() {
-            return Err(VecStoreError::InvalidInput("Empty training set".to_string()));
+            return Err(VecStoreError::InvalidInput(
+                "Empty training set".to_string(),
+            ));
         }
 
         let dim = self.config.dimension;
@@ -247,7 +256,8 @@ impl RaBitQ {
                 variance[i] += diff * diff;
             }
         }
-        self.std = variance.iter()
+        self.std = variance
+            .iter()
             .map(|v| (v / vectors.len() as f32).sqrt().max(1e-6))
             .collect();
 
@@ -273,16 +283,11 @@ impl RaBitQ {
 
         for i in 0..dim {
             // Generate random vector
-            let mut vec: Vec<f32> = (0..dim)
-                .map(|_| rng.random::<f32>() - 0.5)
-                .collect();
+            let mut vec: Vec<f32> = (0..dim).map(|_| rng.random::<f32>() - 0.5).collect();
 
             // Gram-Schmidt orthogonalization
             for row in matrix.iter().take(i) {
-                let dot: f32 = vec.iter()
-                    .zip(row.iter())
-                    .map(|(a, b)| a * b)
-                    .sum();
+                let dot: f32 = vec.iter().zip(row.iter()).map(|(a, b)| a * b).sum();
 
                 for (v, m) in vec.iter_mut().zip(row.iter()) {
                     *v -= dot * m;
@@ -307,14 +312,17 @@ impl RaBitQ {
     #[inline]
     pub fn encode_one(&self, vector: &[f32]) -> Result<BinaryCode> {
         if !self.is_trained {
-            return Err(VecStoreError::InvalidInput("Quantizer not trained".to_string()));
+            return Err(VecStoreError::InvalidInput(
+                "Quantizer not trained".to_string(),
+            ));
         }
 
         let dim = self.config.dimension;
         let mut code = BinaryCode::new(dim);
 
         // Center and normalize
-        let centered: Vec<f32> = vector.iter()
+        let centered: Vec<f32> = vector
+            .iter()
             .zip(self.mean.iter())
             .zip(self.std.iter())
             .map(|((&v, &m), &s)| (v - m) / s)
@@ -327,7 +335,8 @@ impl RaBitQ {
 
         // Apply projection and binarize
         for i in 0..dim {
-            let projected: f32 = self.projection[i].iter()
+            let projected: f32 = self.projection[i]
+                .iter()
                 .zip(centered.iter())
                 .map(|(p, c)| p * c)
                 .sum();
@@ -343,9 +352,7 @@ impl RaBitQ {
     /// Encode multiple vectors
     #[inline]
     pub fn encode(&self, vectors: &[Vec<f32>]) -> Result<Vec<BinaryCode>> {
-        let codes: Result<Vec<_>> = vectors.iter()
-            .map(|v| self.encode_one(v))
-            .collect();
+        let codes: Result<Vec<_>> = vectors.iter().map(|v| self.encode_one(v)).collect();
 
         let codes = codes?;
 
@@ -365,7 +372,8 @@ impl RaBitQ {
         let dim = self.config.dimension;
 
         // Center and normalize query
-        let centered: Vec<f32> = query.iter()
+        let centered: Vec<f32> = query
+            .iter()
             .zip(self.mean.iter())
             .zip(self.std.iter())
             .map(|((&v, &m), &s)| (v - m) / s)
@@ -376,7 +384,8 @@ impl RaBitQ {
         // Project query
         let mut projected = vec![0.0f32; dim];
         for (i, proj_val) in projected.iter_mut().enumerate().take(dim) {
-            *proj_val = self.projection[i].iter()
+            *proj_val = self.projection[i]
+                .iter()
                 .zip(centered.iter())
                 .map(|(p, c)| p * c)
                 .sum();
@@ -408,7 +417,8 @@ impl RaBitQ {
         let oversample = k * self.config.rerank_factor;
 
         // First pass: asymmetric distance
-        let mut candidates: Vec<(usize, f32)> = codes.iter()
+        let mut candidates: Vec<(usize, f32)> = codes
+            .iter()
             .enumerate()
             .map(|(i, code)| (i, self.asymmetric_distance(query, code)))
             .collect();
@@ -420,7 +430,8 @@ impl RaBitQ {
         candidates.truncate(oversample.min(candidates.len()));
 
         // Return results
-        Ok(candidates.into_iter()
+        Ok(candidates
+            .into_iter()
             .take(k)
             .map(|(index, distance)| SearchResult { index, distance })
             .collect())
@@ -490,9 +501,10 @@ impl RaBitQIndex {
             self.codes.push(code);
 
             if let Some(meta) = metadata
-                && i < meta.len() {
-                    self.metadata.insert(id.clone(), meta[i].clone());
-                }
+                && i < meta.len()
+            {
+                self.metadata.insert(id.clone(), meta[i].clone());
+            }
         }
 
         Ok(())
@@ -502,7 +514,8 @@ impl RaBitQIndex {
     pub fn search(&self, query: &[f32], k: usize) -> Result<Vec<IndexSearchResult>> {
         let results = self.quantizer.search(query, &self.codes, k)?;
 
-        Ok(results.into_iter()
+        Ok(results
+            .into_iter()
             .map(|r| {
                 let id = self.ids[r.index].clone();
                 let meta = self.metadata.get(&id).cloned();
@@ -563,7 +576,7 @@ impl RaBitQPQ {
 
         if !config.dimension.is_multiple_of(num_subvectors) {
             return Err(VecStoreError::InvalidInput(
-                "Dimension must be divisible by num_subvectors".to_string()
+                "Dimension must be divisible by num_subvectors".to_string(),
             ));
         }
 
@@ -588,9 +601,8 @@ impl RaBitQPQ {
             let start = i * self.subvector_dim;
             let end = start + self.subvector_dim;
 
-            let subvectors: Vec<Vec<f32>> = vectors.iter()
-                .map(|v| v[start..end].to_vec())
-                .collect();
+            let subvectors: Vec<Vec<f32>> =
+                vectors.iter().map(|v| v[start..end].to_vec()).collect();
 
             sq.train(&subvectors)?;
         }
diff --git a/src/raft_consensus.rs b/src/raft_consensus.rs
index 2480b1f..699b5dc 100644
--- a/src/raft_consensus.rs
+++ b/src/raft_consensus.rs
@@ -27,7 +27,10 @@
 //! ```
 
 use std::collections::{HashMap, VecDeque};
-use std::sync::{RwLock, atomic::{AtomicU64, AtomicBool, Ordering}};
+use std::sync::{
+    RwLock,
+    atomic::{AtomicBool, AtomicU64, Ordering},
+};
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
 use serde::{Deserialize, Serialize};
@@ -192,8 +195,7 @@ pub struct InstallSnapshotRequest {
 }
 
 /// Persistent state (must be saved to stable storage)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[derive(Default)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct PersistentState {
     /// Current term
     pub current_term: u64,
@@ -205,10 +207,8 @@ pub struct PersistentState {
     pub snapshot_metadata: Option<SnapshotMetadata>,
 }
 
-
 /// Volatile state (rebuilt after restart)
-#[derive(Debug, Clone)]
-#[derive(Default)]
+#[derive(Debug, Clone, Default)]
 pub struct VolatileState {
     /// Index of highest log entry known to be committed
     pub commit_index: u64,
@@ -216,7 +216,6 @@ pub struct VolatileState {
     pub last_applied: u64,
 }
 
-
 /// Leader-specific volatile state
 #[derive(Debug, Clone)]
 pub struct LeaderState {
@@ -312,31 +311,41 @@ impl RaftNode {
     where
         F: Fn(&[u8]) -> Vec<u8> + Send + Sync + 'static,
     {
-        let Ok(mut guard) = self.apply_callback.write() else { return; };
+        let Ok(mut guard) = self.apply_callback.write() else {
+            return;
+        };
         *guard = Some(Box::new(callback));
     }
 
     /// Get current term
     pub fn current_term(&self) -> u64 {
-        let Ok(guard) = self.persistent.read() else { return 0; };
+        let Ok(guard) = self.persistent.read() else {
+            return 0;
+        };
         guard.current_term
     }
 
     /// Get current state
     pub fn current_state(&self) -> RaftState {
-        let Ok(guard) = self.state.read() else { return RaftState::Follower; };
+        let Ok(guard) = self.state.read() else {
+            return RaftState::Follower;
+        };
         *guard
     }
 
     /// Get leader ID
     pub fn leader(&self) -> Option<String> {
-        let Ok(guard) = self.leader_id.read() else { return None; };
+        let Ok(guard) = self.leader_id.read() else {
+            return None;
+        };
         guard.clone()
     }
 
     /// Check if this node is leader
     pub fn is_leader(&self) -> bool {
-        let Ok(guard) = self.state.read() else { return false; };
+        let Ok(guard) = self.state.read() else {
+            return false;
+        };
         *guard == RaftState::Leader
     }
 
@@ -349,7 +358,9 @@ impl RaftNode {
         }
 
         let (index, term) = {
-            let mut persistent = self.persistent.write()
+            let mut persistent = self
+                .persistent
+                .write()
                 .map_err(|_| RaftError::LockError("persistent state write lock".into()))?;
             let index = persistent.log.last().map(|e| e.index).unwrap_or(0) + 1;
             let term = persistent.current_term;
@@ -368,14 +379,15 @@ impl RaftNode {
 
         // Add to pending
         if let Ok(mut leader_guard) = self.leader_state.write()
-            && let Some(ref mut leader_state) = *leader_guard {
-                leader_state.pending.push_back(PendingProposal {
-                    index,
-                    term,
-                    data,
-                    proposed_at: Instant::now(),
-                });
-            }
+            && let Some(ref mut leader_state) = *leader_guard
+        {
+            leader_state.pending.push_back(PendingProposal {
+                index,
+                term,
+                data,
+                proposed_at: Instant::now(),
+            });
+        }
 
         self.proposals.fetch_add(1, Ordering::Relaxed);
         Ok(index)
@@ -384,7 +396,10 @@ impl RaftNode {
     /// Handle vote request
     pub fn handle_vote_request(&self, request: VoteRequest) -> VoteResponse {
         let Ok(mut persistent) = self.persistent.write() else {
-            return VoteResponse { term: 0, vote_granted: false };
+            return VoteResponse {
+                term: 0,
+                vote_granted: false,
+            };
         };
 
         // Update term if necessary
@@ -392,7 +407,10 @@ impl RaftNode {
             persistent.current_term = request.term;
             persistent.voted_for = None;
             let Ok(mut state_guard) = self.state.write() else {
-                return VoteResponse { term: persistent.current_term, vote_granted: false };
+                return VoteResponse {
+                    term: persistent.current_term,
+                    vote_granted: false,
+                };
             };
             *state_guard = RaftState::Follower;
         }
@@ -415,13 +433,15 @@ impl RaftNode {
         let last_log_index = last_log.map(|e| e.index).unwrap_or(0);
 
         let log_ok = request.last_log_term > last_log_term
-            || (request.last_log_term == last_log_term
-                && request.last_log_index >= last_log_index);
+            || (request.last_log_term == last_log_term && request.last_log_index >= last_log_index);
 
         if can_vote && log_ok {
             persistent.voted_for = Some(request.candidate_id);
             let Ok(mut heartbeat_guard) = self.last_heartbeat.write() else {
-                return VoteResponse { term: persistent.current_term, vote_granted: false };
+                return VoteResponse {
+                    term: persistent.current_term,
+                    vote_granted: false,
+                };
             };
             *heartbeat_guard = Instant::now();
 
@@ -505,14 +525,18 @@ impl RaftNode {
 
         // Check if log contains entry at prev_log_index with prev_log_term
         if request.prev_log_index > 0 {
-            let prev_entry = persistent.log.iter()
+            let prev_entry = persistent
+                .log
+                .iter()
                 .find(|e| e.index == request.prev_log_index);
 
             match prev_entry {
                 Some(entry) if entry.term != request.prev_log_term => {
                     // Conflict - delete this entry and all that follow
                     let conflict_term = entry.term;
-                    let conflict_index = persistent.log.iter()
+                    let conflict_index = persistent
+                        .log
+                        .iter()
                         .find(|e| e.term == conflict_term)
                         .map(|e| e.index)
                         .unwrap_or(1);
@@ -526,7 +550,7 @@ impl RaftNode {
                         conflict_term: Some(conflict_term),
                         conflict_index: Some(conflict_index),
                     };
-                }
+                },
                 None if request.prev_log_index > 0 => {
                     // Missing entries
                     return AppendEntriesResponse {
@@ -536,8 +560,8 @@ impl RaftNode {
                         conflict_term: None,
                         conflict_index: Some(persistent.log.len() as u64 + 1),
                     };
-                }
-                _ => {}
+                },
+                _ => {},
             }
         }
 
@@ -578,46 +602,61 @@ impl RaftNode {
 
     /// Start election
     pub fn start_election(&self) {
-        let Ok(mut persistent) = self.persistent.write() else { return; };
+        let Ok(mut persistent) = self.persistent.write() else {
+            return;
+        };
         persistent.current_term += 1;
         persistent.voted_for = Some(self.config.node_id.clone());
 
-        let Ok(mut state_guard) = self.state.write() else { return; };
+        let Ok(mut state_guard) = self.state.write() else {
+            return;
+        };
         *state_guard = RaftState::Candidate;
         drop(state_guard);
 
-        let Ok(mut timeout_guard) = self.election_timeout.write() else { return; };
+        let Ok(mut timeout_guard) = self.election_timeout.write() else {
+            return;
+        };
         *timeout_guard = Self::random_election_timeout(&self.config);
         drop(timeout_guard);
 
-        let Ok(mut heartbeat_guard) = self.last_heartbeat.write() else { return; };
+        let Ok(mut heartbeat_guard) = self.last_heartbeat.write() else {
+            return;
+        };
         *heartbeat_guard = Instant::now();
     }
 
     /// Become leader
     pub fn become_leader(&self) {
-        let Ok(mut state_guard) = self.state.write() else { return; };
+        let Ok(mut state_guard) = self.state.write() else {
+            return;
+        };
         *state_guard = RaftState::Leader;
         drop(state_guard);
 
-        let Ok(mut leader_guard) = self.leader_id.write() else { return; };
+        let Ok(mut leader_guard) = self.leader_id.write() else {
+            return;
+        };
         *leader_guard = Some(self.config.node_id.clone());
         drop(leader_guard);
 
         let last_log_index = {
-            let Ok(persistent_guard) = self.persistent.read() else { return; };
+            let Ok(persistent_guard) = self.persistent.read() else {
+                return;
+            };
             persistent_guard.log.last().map(|e| e.index).unwrap_or(0)
         };
 
-        let Ok(mut leader_state_guard) = self.leader_state.write() else { return; };
-        *leader_state_guard = Some(LeaderState::new(
-            &self.config.members,
-            last_log_index,
-        ));
+        let Ok(mut leader_state_guard) = self.leader_state.write() else {
+            return;
+        };
+        *leader_state_guard = Some(LeaderState::new(&self.config.members, last_log_index));
         drop(leader_state_guard);
 
         // Append no-op entry to establish leadership
-        let Ok(mut persistent) = self.persistent.write() else { return; };
+        let Ok(mut persistent) = self.persistent.write() else {
+            return;
+        };
         let index = last_log_index + 1;
         let current_term = persistent.current_term;
         persistent.log.push(LogEntry {
@@ -631,18 +670,24 @@ impl RaftNode {
 
     /// Step down to follower
     pub fn step_down(&self, term: u64) {
-        let Ok(mut persistent) = self.persistent.write() else { return; };
+        let Ok(mut persistent) = self.persistent.write() else {
+            return;
+        };
         if term > persistent.current_term {
             persistent.current_term = term;
             persistent.voted_for = None;
         }
         drop(persistent);
 
-        let Ok(mut state_guard) = self.state.write() else { return; };
+        let Ok(mut state_guard) = self.state.write() else {
+            return;
+        };
         *state_guard = RaftState::Follower;
         drop(state_guard);
 
-        let Ok(mut leader_state_guard) = self.leader_state.write() else { return; };
+        let Ok(mut leader_state_guard) = self.leader_state.write() else {
+            return;
+        };
         *leader_state_guard = None;
     }
 
@@ -661,13 +706,21 @@ impl RaftNode {
             commits: self.commits.load(Ordering::Relaxed),
         };
 
-        let Ok(state_guard) = self.state.read() else { return default_status; };
+        let Ok(state_guard) = self.state.read() else {
+            return default_status;
+        };
         let state = *state_guard;
         drop(state_guard);
 
-        let Ok(persistent) = self.persistent.read() else { return default_status; };
-        let Ok(volatile) = self.volatile.read() else { return default_status; };
-        let Ok(leader_guard) = self.leader_id.read() else { return default_status; };
+        let Ok(persistent) = self.persistent.read() else {
+            return default_status;
+        };
+        let Ok(volatile) = self.volatile.read() else {
+            return default_status;
+        };
+        let Ok(leader_guard) = self.leader_id.read() else {
+            return default_status;
+        };
 
         ClusterStatus {
             node_id: self.config.node_id.clone(),
@@ -685,11 +738,15 @@ impl RaftNode {
 
     /// Check if election timeout elapsed
     pub fn election_timeout_elapsed(&self) -> bool {
-        let Ok(timeout_guard) = self.election_timeout.read() else { return false; };
+        let Ok(timeout_guard) = self.election_timeout.read() else {
+            return false;
+        };
         let timeout = *timeout_guard;
         drop(timeout_guard);
 
-        let Ok(heartbeat_guard) = self.last_heartbeat.read() else { return false; };
+        let Ok(heartbeat_guard) = self.last_heartbeat.read() else {
+            return false;
+        };
         heartbeat_guard.elapsed() > timeout
     }
 
@@ -697,15 +754,21 @@ impl RaftNode {
         while volatile.last_applied < volatile.commit_index {
             volatile.last_applied += 1;
 
-            if let Some(entry) = persistent.log.iter().find(|e| e.index == volatile.last_applied)
-                && entry.entry_type == EntryType::Command {
-                    let Ok(callback_guard) = self.apply_callback.read() else { continue; };
-                    if let Some(ref callback) = *callback_guard {
-                        callback(&entry.data);
-                    }
-                    drop(callback_guard);
-                    self.commits.fetch_add(1, Ordering::Relaxed);
+            if let Some(entry) = persistent
+                .log
+                .iter()
+                .find(|e| e.index == volatile.last_applied)
+                && entry.entry_type == EntryType::Command
+            {
+                let Ok(callback_guard) = self.apply_callback.read() else {
+                    continue;
+                };
+                if let Some(ref callback) = *callback_guard {
+                    callback(&entry.data);
                 }
+                drop(callback_guard);
+                self.commits.fetch_add(1, Ordering::Relaxed);
+            }
         }
     }
 
@@ -716,7 +779,8 @@ impl RaftNode {
         let random = SystemTime::now()
             .duration_since(UNIX_EPOCH)
             .unwrap()
-            .subsec_nanos() as u64 % range;
+            .subsec_nanos() as u64
+            % range;
 
         Duration::from_millis(config.election_timeout.0 + random)
     }
diff --git a/src/rate_limit.rs b/src/rate_limit.rs
index ffb3d05..a861684 100644
--- a/src/rate_limit.rs
+++ b/src/rate_limit.rs
@@ -195,15 +195,21 @@ impl RateLimiter {
         }
 
         // Check if there's a specific limit for this operation
-        let rate = self.inner.config.operation_limits
+        let rate = self
+            .inner
+            .config
+            .operation_limits
             .get(operation)
             .copied()
             .unwrap_or(self.inner.config.requests_per_second);
 
-        let Ok(mut state) = self.inner.state.write() else { return false; };
+        let Ok(mut state) = self.inner.state.write() else {
+            return false;
+        };
         let now = Instant::now();
 
-        let op_state = state.operation_states
+        let op_state = state
+            .operation_states
             .entry(operation.to_string())
             .or_insert_with(|| OperationState {
                 tokens: self.inner.config.burst_size as f64,
@@ -286,7 +292,9 @@ impl RateLimiter {
         let window = Duration::from_secs(1);
 
         // Remove old requests
-        state.window_requests.retain(|t| now.duration_since(*t) < window);
+        state
+            .window_requests
+            .retain(|t| now.duration_since(*t) < window);
 
         let current_count = state.window_requests.len();
         let max_requests = self.inner.config.requests_per_second as usize;
@@ -399,7 +407,9 @@ impl RateLimiter {
 
     /// Reset the rate limiter state
     pub fn reset(&self) {
-        let Ok(mut state) = self.inner.state.write() else { return; };
+        let Ok(mut state) = self.inner.state.write() else {
+            return;
+        };
         state.tokens = self.inner.config.burst_size as f64;
         state.last_refill = Instant::now();
         state.window_requests.clear();
@@ -473,7 +483,9 @@ impl KeyedRateLimiter {
 
     /// Try to acquire for a specific key
     pub fn try_acquire(&self, key: &str) -> bool {
-        let Ok(limiters) = self.limiters.read() else { return false; };
+        let Ok(limiters) = self.limiters.read() else {
+            return false;
+        };
 
         if let Some(limiter) = limiters.get(key) {
             limiter.try_acquire()
@@ -481,7 +493,9 @@ impl KeyedRateLimiter {
             drop(limiters);
 
             // Create new limiter
-            let Ok(mut limiters) = self.limiters.write() else { return false; };
+            let Ok(mut limiters) = self.limiters.write() else {
+                return false;
+            };
             let limiter = limiters
                 .entry(key.to_string())
                 .or_insert_with(|| RateLimiter::new(self.default_config.clone()));
@@ -491,7 +505,9 @@ impl KeyedRateLimiter {
 
     /// Set a custom rate limit for a specific key
     pub fn set_limit(&self, key: &str, requests_per_second: f64) {
-        let Ok(mut limiters) = self.limiters.write() else { return; };
+        let Ok(mut limiters) = self.limiters.write() else {
+            return;
+        };
         let config = RateLimitConfig {
             requests_per_second,
             ..self.default_config.clone()
@@ -501,7 +517,9 @@ impl KeyedRateLimiter {
 
     /// Get stats for all keys
     pub fn all_stats(&self) -> HashMap<String, RateLimitStats> {
-        let Ok(limiters) = self.limiters.read() else { return HashMap::new(); };
+        let Ok(limiters) = self.limiters.read() else {
+            return HashMap::new();
+        };
         limiters
             .iter()
             .map(|(k, v)| (k.clone(), v.stats()))
@@ -702,8 +720,7 @@ mod tests {
 // ============================================================================
 
 /// Scope for rate limiting (global, per-tenant, per-operation)
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-#[derive(Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
 pub enum RateLimitScope {
     /// Global rate limit across all requests
     #[default]
@@ -718,7 +735,6 @@ pub enum RateLimitScope {
     Custom,
 }
 
-
 /// Multi-tier rate limiter that applies limits at different scopes
 ///
 /// For example, you might want:
@@ -764,9 +780,7 @@ impl Default for MultiTierConfig {
 impl MultiTierRateLimiter {
     /// Create a new multi-tier rate limiter
     pub fn new(config: MultiTierConfig) -> Self {
-        let burst = |rps: f64| -> usize {
-            (rps * config.burst_multiplier).max(1.0) as usize
-        };
+        let burst = |rps: f64| -> usize { (rps * config.burst_multiplier).max(1.0) as usize };
 
         Self {
             global: RateLimiter::new(RateLimitConfig {
@@ -799,15 +813,17 @@ impl MultiTierRateLimiter {
 
         // Check per-key limit if key is provided
         if let Some(k) = key
-            && !self.keyed.try_acquire(k) {
-                return false;
-            }
+            && !self.keyed.try_acquire(k)
+        {
+            return false;
+        }
 
         // Check per-operation limit if operation is provided
         if let Some(op) = operation
-            && !self.operations.try_acquire(op) {
-                return false;
-            }
+            && !self.operations.try_acquire(op)
+        {
+            return false;
+        }
 
         true
     }
diff --git a/src/recommendations.rs b/src/recommendations.rs
index 39cf2c6..e53ce19 100644
--- a/src/recommendations.rs
+++ b/src/recommendations.rs
@@ -30,11 +30,11 @@
 //! let recommendations = engine.recommend(request)?;
 //! ```
 
-use std::collections::{HashMap, HashSet};
-use std::cmp::Ordering;
 use serde::{Deserialize, Serialize};
+use std::cmp::Ordering;
+use std::collections::{HashMap, HashSet};
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 // ============================================================================
 // CONFIGURATION
@@ -239,7 +239,10 @@ impl UserProfile {
         if !self.positive_items.contains(&item_id.to_string()) {
             self.positive_items.push(item_id.to_string());
         }
-        *self.item_interactions.entry(item_id.to_string()).or_insert(0) += 1;
+        *self
+            .item_interactions
+            .entry(item_id.to_string())
+            .or_insert(0) += 1;
         self.last_updated = unix_timestamp();
     }
 
@@ -327,18 +330,14 @@ impl RecommendationEngine {
     /// Get or create user profile
     pub fn get_user(&mut self, user_id: &str) -> &mut UserProfile {
         if !self.users.contains_key(user_id) {
-            self.users.insert(user_id.to_string(), UserProfile::new(user_id));
+            self.users
+                .insert(user_id.to_string(), UserProfile::new(user_id));
         }
         self.users.get_mut(user_id).unwrap()
     }
 
     /// Record user interaction
-    pub fn record_interaction(
-        &mut self,
-        user_id: &str,
-        item_id: &str,
-        positive: bool,
-    ) {
+    pub fn record_interaction(&mut self, user_id: &str, item_id: &str, positive: bool) {
         let user = self.get_user(user_id);
         if positive {
             user.record_positive(item_id);
@@ -350,13 +349,15 @@ impl RecommendationEngine {
         if positive {
             for other_item in &user.positive_items.clone() {
                 if other_item != item_id {
-                    *self.cooccurrence
+                    *self
+                        .cooccurrence
                         .entry(item_id.to_string())
                         .or_default()
                         .entry(other_item.clone())
                         .or_insert(0) += 1;
 
-                    *self.cooccurrence
+                    *self
+                        .cooccurrence
                         .entry(other_item.clone())
                         .or_default()
                         .entry(item_id.to_string())
@@ -401,10 +402,14 @@ impl RecommendationEngine {
 
     /// Recommend items similar to a single item
     pub fn recommend_similar(&self, item_id: &str, limit: usize) -> Result<Vec<Recommendation>> {
-        let item_vector = self.items.get(item_id)
+        let item_vector = self
+            .items
+            .get(item_id)
             .ok_or_else(|| VecStoreError::NotFound(format!("Item: {}", item_id)))?;
 
-        let mut results: Vec<Recommendation> = self.items.iter()
+        let mut results: Vec<Recommendation> = self
+            .items
+            .iter()
             .filter(|(id, _)| *id != item_id)
             .map(|(id, vec)| {
                 let score = cosine_similarity(item_vector, vec);
@@ -430,33 +435,31 @@ impl RecommendationEngine {
         if request.positive.is_empty() {
             // Use user profile if available
             if let Some(user_id) = &request.user_id
-                && let Some(user) = self.users.get(user_id) {
-                    if let Some(pref) = &user.preference_vector {
-                        return Ok(pref.clone());
-                    }
-                    // Build from user's positive items
-                    let positive_ids: Vec<&str> = user.positive_items.iter()
-                        .map(|s| s.as_str())
-                        .collect();
-                    return self.average_vectors(&positive_ids);
+                && let Some(user) = self.users.get(user_id)
+            {
+                if let Some(pref) = &user.preference_vector {
+                    return Ok(pref.clone());
                 }
+                // Build from user's positive items
+                let positive_ids: Vec<&str> =
+                    user.positive_items.iter().map(|s| s.as_str()).collect();
+                return self.average_vectors(&positive_ids);
+            }
             return Err(VecStoreError::InvalidInput(
-                "No positive examples or user profile".to_string()
+                "No positive examples or user profile".to_string(),
             ));
         }
 
         match request.strategy {
             RecommendStrategy::AverageVector | RecommendStrategy::Hybrid => {
-                let positive_refs: Vec<&str> = request.positive.iter()
-                    .map(|s| s.as_str())
-                    .collect();
+                let positive_refs: Vec<&str> =
+                    request.positive.iter().map(|s| s.as_str()).collect();
                 let mut avg = self.average_vectors(&positive_refs)?;
 
                 // Subtract negative vectors
                 if !request.negative.is_empty() {
-                    let negative_refs: Vec<&str> = request.negative.iter()
-                        .map(|s| s.as_str())
-                        .collect();
+                    let negative_refs: Vec<&str> =
+                        request.negative.iter().map(|s| s.as_str()).collect();
                     if let Ok(neg_avg) = self.average_vectors(&negative_refs) {
                         for (i, v) in avg.iter_mut().enumerate() {
                             *v -= neg_avg[i] * 0.5;
@@ -473,14 +476,15 @@ impl RecommendationEngine {
                 }
 
                 Ok(avg)
-            }
+            },
             _ => {
                 // For other strategies, use first positive
                 let first = &request.positive[0];
-                self.items.get(first)
+                self.items
+                    .get(first)
                     .cloned()
                     .ok_or_else(|| VecStoreError::NotFound(format!("Item: {}", first)))
-            }
+            },
         }
     }
 
@@ -515,11 +519,15 @@ impl RecommendationEngine {
         query_vector: &[f32],
         request: &RecommendRequest,
     ) -> Result<Vec<Recommendation>> {
-        let excluded: HashSet<_> = request.positive.iter()
+        let excluded: HashSet<_> = request
+            .positive
+            .iter()
             .chain(request.negative.iter())
             .collect();
 
-        let candidates: Vec<Recommendation> = self.items.iter()
+        let candidates: Vec<Recommendation> = self
+            .items
+            .iter()
             .filter(|(id, _)| !excluded.contains(id))
             .map(|(id, vec)| {
                 let score = cosine_similarity(query_vector, vec);
@@ -551,10 +559,11 @@ impl RecommendationEngine {
 
             for positive_id in &request.positive {
                 if let Some(cooc) = self.cooccurrence.get(positive_id)
-                    && let Some(&freq) = cooc.get(&candidate.id) {
-                        collab_score += freq as f32;
-                        count += 1;
-                    }
+                    && let Some(&freq) = cooc.get(&candidate.id)
+                {
+                    collab_score += freq as f32;
+                    count += 1;
+                }
             }
 
             if count > 0 {
@@ -563,7 +572,8 @@ impl RecommendationEngine {
                 candidate.collaborative_score = Some(collab_score);
 
                 // Blend with content score
-                candidate.score = candidate.content_score * (1.0 - self.config.collaborative_weight)
+                candidate.score = candidate.content_score
+                    * (1.0 - self.config.collaborative_weight)
                     + collab_score * self.config.collaborative_weight;
             }
         }
@@ -606,9 +616,7 @@ impl RecommendationEngine {
             total_items: self.items.len(),
             total_users: self.users.len(),
             cached_similarities: self.similarity_cache.len(),
-            cooccurrence_pairs: self.cooccurrence.values()
-                .map(|m| m.len())
-                .sum(),
+            cooccurrence_pairs: self.cooccurrence.values().map(|m| m.len()).sum(),
         }
     }
 }
@@ -653,9 +661,15 @@ mod tests {
     fn test_recommend_similar() {
         let mut engine = RecommendationEngine::new(4);
 
-        engine.add_item("item1", vec![1.0, 0.0, 0.0, 0.0], None).unwrap();
-        engine.add_item("item2", vec![0.9, 0.1, 0.0, 0.0], None).unwrap();
-        engine.add_item("item3", vec![0.0, 1.0, 0.0, 0.0], None).unwrap();
+        engine
+            .add_item("item1", vec![1.0, 0.0, 0.0, 0.0], None)
+            .unwrap();
+        engine
+            .add_item("item2", vec![0.9, 0.1, 0.0, 0.0], None)
+            .unwrap();
+        engine
+            .add_item("item3", vec![0.0, 1.0, 0.0, 0.0], None)
+            .unwrap();
 
         let results = engine.recommend_similar("item1", 10).unwrap();
         assert_eq!(results.len(), 2);
@@ -666,10 +680,18 @@ mod tests {
     fn test_recommend_with_positives() {
         let mut engine = RecommendationEngine::new(4);
 
-        engine.add_item("liked1", vec![1.0, 0.0, 0.0, 0.0], None).unwrap();
-        engine.add_item("liked2", vec![0.8, 0.2, 0.0, 0.0], None).unwrap();
-        engine.add_item("candidate1", vec![0.9, 0.1, 0.0, 0.0], None).unwrap();
-        engine.add_item("candidate2", vec![0.0, 0.0, 1.0, 0.0], None).unwrap();
+        engine
+            .add_item("liked1", vec![1.0, 0.0, 0.0, 0.0], None)
+            .unwrap();
+        engine
+            .add_item("liked2", vec![0.8, 0.2, 0.0, 0.0], None)
+            .unwrap();
+        engine
+            .add_item("candidate1", vec![0.9, 0.1, 0.0, 0.0], None)
+            .unwrap();
+        engine
+            .add_item("candidate2", vec![0.0, 0.0, 1.0, 0.0], None)
+            .unwrap();
 
         let request = RecommendRequest::new()
             .with_positive(&["liked1", "liked2"])
@@ -686,9 +708,15 @@ mod tests {
         let mut engine = RecommendationEngine::new(4);
 
         // Add items
-        engine.add_item("item1", vec![1.0, 0.0, 0.0, 0.0], None).unwrap();
-        engine.add_item("item2", vec![0.0, 1.0, 0.0, 0.0], None).unwrap();
-        engine.add_item("item3", vec![0.0, 0.0, 1.0, 0.0], None).unwrap();
+        engine
+            .add_item("item1", vec![1.0, 0.0, 0.0, 0.0], None)
+            .unwrap();
+        engine
+            .add_item("item2", vec![0.0, 1.0, 0.0, 0.0], None)
+            .unwrap();
+        engine
+            .add_item("item3", vec![0.0, 0.0, 1.0, 0.0], None)
+            .unwrap();
 
         // User1 likes item1 and item2
         engine.record_interaction("user1", "item1", true);
diff --git a/src/recommender.rs b/src/recommender.rs
index 9def92c..2d1d728 100644
--- a/src/recommender.rs
+++ b/src/recommender.rs
@@ -31,7 +31,7 @@
 //! let recommendations = recommender.recommend(&preferences, 10)?;
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -315,10 +315,7 @@ impl CollaborativeRecommender {
             .or_default()
             .insert(item_id.clone(), rating);
 
-        self.item_users
-            .entry(item_id)
-            .or_default()
-            .push(user_id);
+        self.item_users.entry(item_id).or_default().push(user_id);
     }
 
     /// Get recommendations for a user
diff --git a/src/reranking/colbert.rs b/src/reranking/colbert.rs
index c3dd96d..d255e4a 100644
--- a/src/reranking/colbert.rs
+++ b/src/reranking/colbert.rs
@@ -40,9 +40,9 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
 #[cfg(feature = "embeddings")]
 use anyhow::Context;
+use anyhow::{Result, anyhow};
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 #[cfg(feature = "embeddings")]
@@ -51,7 +51,7 @@ use std::sync::{Arc, Mutex};
 #[cfg(feature = "embeddings")]
 use ndarray::Array2;
 #[cfg(feature = "embeddings")]
-use ort::session::{builder::GraphOptimizationLevel, Session};
+use ort::session::{Session, builder::GraphOptimizationLevel};
 #[cfg(feature = "embeddings")]
 use std::sync::RwLock;
 #[cfg(feature = "embeddings")]
@@ -476,8 +476,7 @@ impl ColBERTReranker {
         }
 
         // Create 2D arrays (batch_size=1, seq_length)
-        let input_ids_array =
-            Array2::from_shape_vec((1, max_tokens), padded_input_ids.clone())?;
+        let input_ids_array = Array2::from_shape_vec((1, max_tokens), padded_input_ids.clone())?;
         let attention_mask_array =
             Array2::from_shape_vec((1, max_tokens), padded_attention_mask.clone())?;
 
@@ -486,12 +485,10 @@ impl ColBERTReranker {
         let attention_mask_tensor = ort::value::Tensor::from_array(attention_mask_array)?;
 
         // Run inference using ort 2.0 inputs! macro
-        let mut session_guard = session.lock()
+        let mut session_guard = session
+            .lock()
             .map_err(|e| anyhow!("Failed to lock session: {}", e))?;
-        let outputs = session_guard.run(ort::inputs![
-            input_ids_tensor,
-            attention_mask_tensor
-        ])?;
+        let outputs = session_guard.run(ort::inputs![input_ids_tensor, attention_mask_tensor])?;
 
         // Extract token embeddings using ort 2.0 API
         // ColBERT output shape: (batch_size, seq_length, embedding_dim)
@@ -559,7 +556,10 @@ impl ColBERTReranker {
         {
             // Check query cache first
             {
-                let cache = self.query_cache.read().map_err(|e| anyhow!("Cache lock error: {}", e))?;
+                let cache = self
+                    .query_cache
+                    .read()
+                    .map_err(|e| anyhow!("Cache lock error: {}", e))?;
                 if let Some(cached) = cache.get(query) {
                     return Ok(cached.clone());
                 }
@@ -576,7 +576,10 @@ impl ColBERTReranker {
 
             // Cache the result
             {
-                let mut cache = self.query_cache.write().map_err(|e| anyhow!("Cache lock error: {}", e))?;
+                let mut cache = self
+                    .query_cache
+                    .write()
+                    .map_err(|e| anyhow!("Cache lock error: {}", e))?;
                 cache.insert(query.to_string(), embeddings.clone());
             }
 
@@ -612,10 +615,7 @@ impl ColBERTReranker {
 
     /// Encode multiple documents in a batch (more efficient than encoding one by one)
     #[cfg(feature = "embeddings")]
-    pub async fn encode_documents_batch(
-        &self,
-        documents: &[&str],
-    ) -> Result<Vec<TokenEmbeddings>> {
+    pub async fn encode_documents_batch(&self, documents: &[&str]) -> Result<Vec<TokenEmbeddings>> {
         let session = self
             .session
             .as_ref()
@@ -654,7 +654,10 @@ impl ColBERTReranker {
 
             // Tokenize batch
             let encodings = tokenizer
-                .encode_batch(batch_texts.iter().map(|s| s.as_str()).collect::<Vec<_>>(), true)
+                .encode_batch(
+                    batch_texts.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
+                    true,
+                )
                 .map_err(|e| anyhow!("Batch tokenization failed: {}", e))?;
 
             // Prepare batch input tensors
@@ -681,20 +684,21 @@ impl ColBERTReranker {
             // Create batch arrays
             let input_ids_array =
                 Array2::from_shape_vec((current_batch_size, max_tokens), all_input_ids)?;
-            let attention_mask_array =
-                Array2::from_shape_vec((current_batch_size, max_tokens), all_attention_masks.clone())?;
+            let attention_mask_array = Array2::from_shape_vec(
+                (current_batch_size, max_tokens),
+                all_attention_masks.clone(),
+            )?;
 
             // Create Tensor objects for ort 2.0
             let input_ids_tensor = ort::value::Tensor::from_array(input_ids_array)?;
             let attention_mask_tensor = ort::value::Tensor::from_array(attention_mask_array)?;
 
             // Run batch inference using ort 2.0 inputs! macro
-            let mut session_guard = session.lock()
+            let mut session_guard = session
+                .lock()
                 .map_err(|e| anyhow!("Failed to lock session: {}", e))?;
-            let outputs = session_guard.run(ort::inputs![
-                input_ids_tensor,
-                attention_mask_tensor
-            ])?;
+            let outputs =
+                session_guard.run(ort::inputs![input_ids_tensor, attention_mask_tensor])?;
 
             // Extract and process embeddings using ort 2.0 API
             let token_embeddings_view = outputs[0]
@@ -838,9 +842,11 @@ impl ColBERTReranker {
         for (q_idx, query_emb) in query_tokens.embeddings.iter().enumerate() {
             // Skip padding tokens if attention mask is available
             if let Some(ref mask) = query_tokens.attention_mask
-                && q_idx < mask.len() && mask[q_idx] == 0 {
-                    continue;
-                }
+                && q_idx < mask.len()
+                && mask[q_idx] == 0
+            {
+                continue;
+            }
 
             let mut max_sim = f32::NEG_INFINITY;
 
@@ -848,9 +854,11 @@ impl ColBERTReranker {
             for (d_idx, doc_emb) in doc_tokens.embeddings.iter().enumerate() {
                 // Skip padding tokens if attention mask is available
                 if let Some(ref mask) = doc_tokens.attention_mask
-                    && d_idx < mask.len() && mask[d_idx] == 0 {
-                        continue;
-                    }
+                    && d_idx < mask.len()
+                    && mask[d_idx] == 0
+                {
+                    continue;
+                }
 
                 let sim = self.compute_token_similarity(query_emb, doc_emb);
                 max_sim = max_sim.max(sim);
@@ -937,7 +945,10 @@ impl ColBERTReranker {
     /// Clear the query cache
     #[cfg(feature = "embeddings")]
     pub fn clear_query_cache(&self) -> Result<()> {
-        let mut cache = self.query_cache.write().map_err(|e| anyhow!("Cache lock error: {}", e))?;
+        let mut cache = self
+            .query_cache
+            .write()
+            .map_err(|e| anyhow!("Cache lock error: {}", e))?;
         cache.clear();
         Ok(())
     }
@@ -945,11 +956,7 @@ impl ColBERTReranker {
     /// Get cache statistics
     pub fn cache_stats(&self) -> CacheStats {
         #[cfg(feature = "embeddings")]
-        let query_cache_size = self
-            .query_cache
-            .read()
-            .map(|c| c.len())
-            .unwrap_or(0);
+        let query_cache_size = self.query_cache.read().map(|c| c.len()).unwrap_or(0);
 
         #[cfg(not(feature = "embeddings"))]
         let query_cache_size = 0;
@@ -1058,7 +1065,9 @@ impl ColBERTBatchReranker {
         };
 
         // Compute scores for all documents
-        let scores = self.reranker.compute_scores_batch(&query_tokens, &doc_embeddings)?;
+        let scores = self
+            .reranker
+            .compute_scores_batch(&query_tokens, &doc_embeddings)?;
 
         // Create indexed scores and sort
         let mut indexed_scores: Vec<(usize, f32)> = scores.into_iter().enumerate().collect();
@@ -1094,19 +1103,20 @@ impl ColBERTBatchReranker {
                 doc_embeddings.push(cached.clone());
             } else {
                 let embeddings = self.reranker.encode_document(doc_text).await?;
-                self.reranker.cache_document(doc_id.clone(), embeddings.clone());
+                self.reranker
+                    .cache_document(doc_id.clone(), embeddings.clone());
                 doc_embeddings.push(embeddings);
             }
         }
 
         // Compute scores
-        let scores = self.reranker.compute_scores_batch(&query_tokens, &doc_embeddings)?;
+        let scores = self
+            .reranker
+            .compute_scores_batch(&query_tokens, &doc_embeddings)?;
 
         // Create indexed scores and sort
-        let mut indexed_scores: Vec<(String, f32)> = doc_ids
-            .into_iter()
-            .zip(scores.into_iter())
-            .collect();
+        let mut indexed_scores: Vec<(String, f32)> =
+            doc_ids.into_iter().zip(scores.into_iter()).collect();
         indexed_scores.sort_by(|a, b| b.1.total_cmp(&a.1));
 
         // Return top-k
@@ -1141,7 +1151,11 @@ mod tests {
     #[test]
     fn test_token_embeddings_with_metadata() {
         let embeddings = vec![vec![0.1, 0.2], vec![0.3, 0.4], vec![0.5, 0.6]];
-        let tokens = vec!["hello".to_string(), "world".to_string(), "[PAD]".to_string()];
+        let tokens = vec![
+            "hello".to_string(),
+            "world".to_string(),
+            "[PAD]".to_string(),
+        ];
         let mask = vec![1, 1, 0];
 
         let token_embs = TokenEmbeddings::with_metadata(embeddings, tokens, mask);
@@ -1229,10 +1243,7 @@ mod tests {
             vec![1, 0], // Second token is padding
         );
 
-        let doc_tokens = TokenEmbeddings::new(vec![
-            vec![1.0, 0.0, 0.0],
-            vec![0.0, 1.0, 0.0],
-        ]);
+        let doc_tokens = TokenEmbeddings::new(vec![vec![1.0, 0.0, 0.0], vec![0.0, 1.0, 0.0]]);
 
         let score = reranker.compute_score(&query_tokens, &doc_tokens).unwrap();
 
@@ -1259,7 +1270,9 @@ mod tests {
             TokenEmbeddings::new(vec![vec![0.5, 0.5, 0.0]]), // Partial match
         ];
 
-        let scores = reranker.compute_scores_batch(&query_tokens, &doc_batch).unwrap();
+        let scores = reranker
+            .compute_scores_batch(&query_tokens, &doc_batch)
+            .unwrap();
 
         assert_eq!(scores.len(), 3);
         assert!(scores[0] > scores[2]); // Perfect match > partial
diff --git a/src/reranking/cross_encoder.rs b/src/reranking/cross_encoder.rs
index f5c0cf0..0b716c3 100644
--- a/src/reranking/cross_encoder.rs
+++ b/src/reranking/cross_encoder.rs
@@ -6,9 +6,9 @@
 
 use super::Reranker;
 use crate::store::Neighbor;
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result, anyhow};
 use ndarray::Array2;
-use ort::session::{builder::GraphOptimizationLevel, Session};
+use ort::session::{Session, builder::GraphOptimizationLevel};
 use std::path::Path;
 use std::sync::{Arc, Mutex};
 use tokenizers::tokenizer::Tokenizer;
@@ -190,10 +190,10 @@ impl CrossEncoderReranker {
                             .with_context(|| format!("Failed to copy {} to {:?}", file, dest))?;
                     }
                     println!("   ✓ Downloaded {}", file);
-                }
+                },
                 Err(e) => {
                     println!("   ⚠ {} not found (optional): {}", file, e);
-                }
+                },
             }
         }
 
@@ -206,13 +206,12 @@ impl CrossEncoderReranker {
                 Ok(cached_path) => {
                     let dest = target_dir.join("model.onnx");
                     if cached_path != dest {
-                        fs::copy(&cached_path, &dest)
-                            .context("Failed to copy ONNX model")?;
+                        fs::copy(&cached_path, &dest).context("Failed to copy ONNX model")?;
                     }
                     println!("   ✓ Downloaded ONNX model from {}", onnx_file);
                     onnx_found = true;
                     break;
-                }
+                },
                 Err(_) => continue,
             }
         }
@@ -239,10 +238,16 @@ impl CrossEncoderReranker {
         let tokenizer_path = target_dir.join("tokenizer.json");
 
         if !model_path.exists() {
-            return Err(anyhow!("Model file not found after download: {:?}", model_path));
+            return Err(anyhow!(
+                "Model file not found after download: {:?}",
+                model_path
+            ));
         }
         if !tokenizer_path.exists() {
-            return Err(anyhow!("Tokenizer file not found after download: {:?}", tokenizer_path));
+            return Err(anyhow!(
+                "Tokenizer file not found after download: {:?}",
+                tokenizer_path
+            ));
         }
 
         println!("✓ Model downloaded successfully!");
@@ -294,12 +299,11 @@ impl CrossEncoderReranker {
         let attention_mask_tensor = ort::value::Tensor::from_array(attention_mask_array)?;
 
         // Run inference using ort 2.0 inputs! macro
-        let mut session_guard = self.session.lock()
+        let mut session_guard = self
+            .session
+            .lock()
             .map_err(|e| anyhow!("Failed to lock session: {}", e))?;
-        let outputs = session_guard.run(ort::inputs![
-            input_ids_tensor,
-            attention_mask_tensor
-        ])?;
+        let outputs = session_guard.run(ort::inputs![input_ids_tensor, attention_mask_tensor])?;
 
         // Extract logits (typically shape [1, 1] or [1, 2] for binary classification)
         let logits_view = outputs[0].try_extract_array::<f32>()?;
@@ -372,19 +376,16 @@ impl Reranker for CrossEncoderReranker {
             match self.score_pair(query, doc_text) {
                 Ok(score) => {
                     neighbor.score = score;
-                }
+                },
                 Err(e) => {
                     eprintln!("Warning: Failed to score document {}: {}", neighbor.id, e);
                     // Keep original score
-                }
+                },
             }
         }
 
         // Sort by score (descending)
-        results.sort_by(|a, b| {
-            b.score
-                .total_cmp(&a.score)
-        });
+        results.sort_by(|a, b| b.score.total_cmp(&a.score));
 
         // Return top_k
         Ok(results.into_iter().take(top_k).collect())
diff --git a/src/reranking/mod.rs b/src/reranking/mod.rs
index dbbbdd4..340596d 100644
--- a/src/reranking/mod.rs
+++ b/src/reranking/mod.rs
@@ -195,8 +195,7 @@ impl Reranker for MMRReranker {
                 .max_by(|(_, a), (_, b)| {
                     let score_a = self.mmr_score(a, &selected_refs);
                     let score_b = self.mmr_score(b, &selected_refs);
-                    score_a
-                        .total_cmp(&score_b)
+                    score_a.total_cmp(&score_b)
                 })
                 .map(|(idx, _)| idx)
                 .unwrap();
diff --git a/src/rest_api.rs b/src/rest_api.rs
index aa3f8a2..5bf8847 100644
--- a/src/rest_api.rs
+++ b/src/rest_api.rs
@@ -485,16 +485,19 @@ impl OpenApiGenerator {
     }
 
     fn add_schemas(&mut self) {
-        self.schemas.insert("Collection".to_string(), serde_json::json!({
-            "type": "object",
-            "properties": {
-                "name": {"type": "string"},
-                "dimension": {"type": "integer"},
-                "metric": {"type": "string", "enum": ["cosine", "euclidean", "dot"]},
-                "vector_count": {"type": "integer"},
-                "created_at": {"type": "string", "format": "date-time"}
-            }
-        }));
+        self.schemas.insert(
+            "Collection".to_string(),
+            serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "dimension": {"type": "integer"},
+                    "metric": {"type": "string", "enum": ["cosine", "euclidean", "dot"]},
+                    "vector_count": {"type": "integer"},
+                    "created_at": {"type": "string", "format": "date-time"}
+                }
+            }),
+        );
 
         self.schemas.insert("CreateCollectionRequest".to_string(), serde_json::json!({
             "type": "object",
@@ -506,65 +509,80 @@ impl OpenApiGenerator {
             }
         }));
 
-        self.schemas.insert("Point".to_string(), serde_json::json!({
-            "type": "object",
-            "required": ["id", "vector"],
-            "properties": {
-                "id": {"type": "string"},
-                "vector": {"type": "array", "items": {"type": "number"}},
-                "payload": {"type": "object", "additionalProperties": true}
-            }
-        }));
-
-        self.schemas.insert("InsertPointsRequest".to_string(), serde_json::json!({
-            "type": "object",
-            "required": ["points"],
-            "properties": {
-                "points": {
-                    "type": "array",
-                    "items": {"$ref": "#/components/schemas/Point"}
+        self.schemas.insert(
+            "Point".to_string(),
+            serde_json::json!({
+                "type": "object",
+                "required": ["id", "vector"],
+                "properties": {
+                    "id": {"type": "string"},
+                    "vector": {"type": "array", "items": {"type": "number"}},
+                    "payload": {"type": "object", "additionalProperties": true}
                 }
-            }
-        }));
-
-        self.schemas.insert("SearchRequest".to_string(), serde_json::json!({
-            "type": "object",
-            "required": ["vector"],
-            "properties": {
-                "vector": {"type": "array", "items": {"type": "number"}},
-                "limit": {"type": "integer", "default": 10, "maximum": 1000},
-                "filter": {"type": "object"},
-                "with_payload": {"type": "boolean", "default": true},
-                "with_vector": {"type": "boolean", "default": false}
-            }
-        }));
-
-        self.schemas.insert("SearchResponse".to_string(), serde_json::json!({
-            "type": "object",
-            "properties": {
-                "result": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "id": {"type": "string"},
-                            "score": {"type": "number"},
-                            "payload": {"type": "object"},
-                            "vector": {"type": "array", "items": {"type": "number"}}
-                        }
+            }),
+        );
+
+        self.schemas.insert(
+            "InsertPointsRequest".to_string(),
+            serde_json::json!({
+                "type": "object",
+                "required": ["points"],
+                "properties": {
+                    "points": {
+                        "type": "array",
+                        "items": {"$ref": "#/components/schemas/Point"}
                     }
-                },
-                "time_ms": {"type": "number"}
-            }
-        }));
-
-        self.schemas.insert("InsertResult".to_string(), serde_json::json!({
-            "type": "object",
-            "properties": {
-                "inserted_count": {"type": "integer"},
-                "operation_id": {"type": "string"}
-            }
-        }));
+                }
+            }),
+        );
+
+        self.schemas.insert(
+            "SearchRequest".to_string(),
+            serde_json::json!({
+                "type": "object",
+                "required": ["vector"],
+                "properties": {
+                    "vector": {"type": "array", "items": {"type": "number"}},
+                    "limit": {"type": "integer", "default": 10, "maximum": 1000},
+                    "filter": {"type": "object"},
+                    "with_payload": {"type": "boolean", "default": true},
+                    "with_vector": {"type": "boolean", "default": false}
+                }
+            }),
+        );
+
+        self.schemas.insert(
+            "SearchResponse".to_string(),
+            serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "result": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {"type": "string"},
+                                "score": {"type": "number"},
+                                "payload": {"type": "object"},
+                                "vector": {"type": "array", "items": {"type": "number"}}
+                            }
+                        }
+                    },
+                    "time_ms": {"type": "number"}
+                }
+            }),
+        );
+
+        self.schemas.insert(
+            "InsertResult".to_string(),
+            serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "inserted_count": {"type": "integer"},
+                    "operation_id": {"type": "string"}
+                }
+            }),
+        );
     }
 
     /// Generate OpenAPI spec
@@ -572,7 +590,9 @@ impl OpenApiGenerator {
         let mut paths: HashMap<String, serde_json::Value> = HashMap::new();
 
         for route in &self.routes {
-            let path_entry = paths.entry(route.path.clone()).or_insert_with(|| serde_json::json!({}));
+            let path_entry = paths
+                .entry(route.path.clone())
+                .or_insert_with(|| serde_json::json!({}));
 
             let method = match route.method {
                 HttpMethod::GET => "get",
@@ -670,7 +690,8 @@ impl OpenApiGenerator {
             if let Some(props) = schema.get("properties").and_then(|p| p.as_object()) {
                 for (prop_name, prop_schema) in props {
                     let ts_type = self.json_schema_to_ts(prop_schema);
-                    let required = schema.get("required")
+                    let required = schema
+                        .get("required")
                         .and_then(|r| r.as_array())
                         .map(|arr| arr.iter().any(|v| v.as_str() == Some(prop_name)))
                         .unwrap_or(false);
@@ -696,11 +717,12 @@ impl OpenApiGenerator {
             Some("integer") | Some("number") => "number".to_string(),
             Some("boolean") => "boolean".to_string(),
             Some("array") => {
-                let items_type = schema.get("items")
+                let items_type = schema
+                    .get("items")
                     .map(|i| self.json_schema_to_ts(i))
                     .unwrap_or_else(|| "unknown".to_string());
                 format!("{}[]", items_type)
-            }
+            },
             Some("object") => "Record<string, any>".to_string(),
             _ => "unknown".to_string(),
         }
@@ -731,14 +753,16 @@ impl ApiRateLimiter {
 
     /// Check if request is allowed
     pub fn allow(&self, client_id: &str) -> bool {
-        let Ok(mut clients) = self.clients.write() else { return false; };
+        let Ok(mut clients) = self.clients.write() else {
+            return false;
+        };
 
-        let client = clients.entry(client_id.to_string()).or_insert_with(|| {
-            ClientLimit {
+        let client = clients
+            .entry(client_id.to_string())
+            .or_insert_with(|| ClientLimit {
                 tokens: self.rpm,
                 last_refill: Instant::now(),
-            }
-        });
+            });
 
         // Refill tokens
         let elapsed = client.last_refill.elapsed();
diff --git a/src/scann.rs b/src/scann.rs
index afbb3a1..6a3a0f8 100644
--- a/src/scann.rs
+++ b/src/scann.rs
@@ -53,7 +53,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 
diff --git a/src/schema.rs b/src/schema.rs
index b5bbca0..825a559 100644
--- a/src/schema.rs
+++ b/src/schema.rs
@@ -130,52 +130,56 @@ impl FieldSchema {
     pub fn validate(&self, value: &Value) -> Result<(), ValidationError> {
         // Type validation
         match (&self.field_type, value) {
-            (FieldType::String, Value::String(_)) => {}
-            (FieldType::Number, Value::Number(_)) => {}
-            (FieldType::Integer, Value::Number(n)) if n.is_i64() || n.is_u64() => {}
-            (FieldType::Boolean, Value::Bool(_)) => {}
-            (FieldType::Array, Value::Array(_)) => {}
-            (FieldType::Object, Value::Object(_)) => {}
-            (FieldType::Null, Value::Null) => {}
+            (FieldType::String, Value::String(_)) => {},
+            (FieldType::Number, Value::Number(_)) => {},
+            (FieldType::Integer, Value::Number(n)) if n.is_i64() || n.is_u64() => {},
+            (FieldType::Boolean, Value::Bool(_)) => {},
+            (FieldType::Array, Value::Array(_)) => {},
+            (FieldType::Object, Value::Object(_)) => {},
+            (FieldType::Null, Value::Null) => {},
             _ => {
                 return Err(ValidationError::TypeError {
                     expected: format!("{:?}", self.field_type),
                     actual: value.clone(),
                     message: self.error_message.clone(),
                 });
-            }
+            },
         }
 
         // Range validation for numbers
         if let Value::Number(n) = value
-            && let Some(n_f64) = n.as_f64() {
-                if let Some(min) = self.min
-                    && n_f64 < min {
-                        return Err(ValidationError::RangeError {
-                            value: n_f64,
-                            min: Some(min),
-                            max: None,
-                        });
-                    }
-
-                if let Some(max) = self.max
-                    && n_f64 > max {
-                        return Err(ValidationError::RangeError {
-                            value: n_f64,
-                            min: None,
-                            max: Some(max),
-                        });
-                    }
+            && let Some(n_f64) = n.as_f64()
+        {
+            if let Some(min) = self.min
+                && n_f64 < min
+            {
+                return Err(ValidationError::RangeError {
+                    value: n_f64,
+                    min: Some(min),
+                    max: None,
+                });
             }
 
-        // Allowed values validation
-        if let Some(ref allowed) = self.allowed_values
-            && !allowed.contains(value) {
-                return Err(ValidationError::EnumError {
-                    value: value.clone(),
-                    allowed: allowed.clone(),
+            if let Some(max) = self.max
+                && n_f64 > max
+            {
+                return Err(ValidationError::RangeError {
+                    value: n_f64,
+                    min: None,
+                    max: Some(max),
                 });
             }
+        }
+
+        // Allowed values validation
+        if let Some(ref allowed) = self.allowed_values
+            && !allowed.contains(value)
+        {
+            return Err(ValidationError::EnumError {
+                value: value.clone(),
+                allowed: allowed.clone(),
+            });
+        }
 
         // Pattern validation for strings
         if let (Some(pattern), Value::String(s)) = (&self.pattern, value) {
@@ -230,8 +234,8 @@ impl Schema {
             None => {
                 return Err(ValidationError::NotAnObject {
                     actual: metadata.clone(),
-                })
-            }
+                });
+            },
         };
 
         // Check required fields
@@ -328,7 +332,7 @@ impl std::fmt::Display for ValidationError {
                 } else {
                     write!(f, "Type error: expected {}, got {:?}", expected, actual)
                 }
-            }
+            },
             Self::RangeError { value, min, max } => {
                 if let (Some(min), Some(max)) = (min, max) {
                     write!(f, "Value {} out of range [{}, {}]", value, min, max)
@@ -339,25 +343,25 @@ impl std::fmt::Display for ValidationError {
                 } else {
                     write!(f, "Range error for value {}", value)
                 }
-            }
+            },
             Self::EnumError { value, allowed } => {
                 write!(f, "Value {:?} not in allowed values: {:?}", value, allowed)
-            }
+            },
             Self::PatternError { value, pattern } => {
                 write!(f, "Value '{}' does not match pattern '{}'", value, pattern)
-            }
+            },
             Self::MissingField { field } => {
                 write!(f, "Required field '{}' is missing", field)
-            }
+            },
             Self::UnexpectedField { field } => {
                 write!(f, "Unexpected field '{}'", field)
-            }
+            },
             Self::FieldError { field, error } => {
                 write!(f, "Field '{}': {}", field, error)
-            }
+            },
             Self::NotAnObject { actual } => {
                 write!(f, "Metadata must be an object, got {:?}", actual)
-            }
+            },
         }
     }
 }
diff --git a/src/sdk_gen.rs b/src/sdk_gen.rs
index ccc18b2..75686ed 100644
--- a/src/sdk_gen.rs
+++ b/src/sdk_gen.rs
@@ -177,7 +177,10 @@ impl SdkGenerator {
                 },
                 FieldDef {
                     name: "payload".to_string(),
-                    field_type: FieldType::Map(Box::new(FieldType::String), Box::new(FieldType::Any)),
+                    field_type: FieldType::Map(
+                        Box::new(FieldType::String),
+                        Box::new(FieldType::Any),
+                    ),
                     optional: true,
                     description: Some("Metadata payload".to_string()),
                     default: None,
@@ -206,7 +209,10 @@ impl SdkGenerator {
                 },
                 FieldDef {
                     name: "payload".to_string(),
-                    field_type: FieldType::Map(Box::new(FieldType::String), Box::new(FieldType::Any)),
+                    field_type: FieldType::Map(
+                        Box::new(FieldType::String),
+                        Box::new(FieldType::Any),
+                    ),
                     optional: true,
                     description: None,
                     default: None,
@@ -278,7 +284,10 @@ impl SdkGenerator {
                 },
                 FieldDef {
                     name: "filter".to_string(),
-                    field_type: FieldType::Map(Box::new(FieldType::String), Box::new(FieldType::Any)),
+                    field_type: FieldType::Map(
+                        Box::new(FieldType::String),
+                        Box::new(FieldType::Any),
+                    ),
                     optional: true,
                     description: Some("Metadata filter".to_string()),
                     default: None,
@@ -441,7 +450,9 @@ impl SdkGenerator {
         output.push_str("    this.apiKey = apiKey;\n");
         output.push_str("  }\n\n");
 
-        output.push_str("  private async request<T>(method: string, path: string, body?: any): Promise<T> {\n");
+        output.push_str(
+            "  private async request<T>(method: string, path: string, body?: any): Promise<T> {\n",
+        );
         output.push_str("    const headers: Record<string, string> = {\n");
         output.push_str("      'Content-Type': 'application/json',\n");
         output.push_str("    };\n");
@@ -452,7 +463,9 @@ impl SdkGenerator {
         output.push_str("      body: body ? JSON.stringify(body) : undefined,\n");
         output.push_str("    });\n\n");
         output.push_str("    if (!response.ok) {\n");
-        output.push_str("      throw new Error(`HTTP ${response.status}: ${await response.text()}`);\n");
+        output.push_str(
+            "      throw new Error(`HTTP ${response.status}: ${await response.text()}`);\n",
+        );
         output.push_str("    }\n\n");
         output.push_str("    return response.json();\n");
         output.push_str("  }\n\n");
@@ -463,8 +476,10 @@ impl SdkGenerator {
             let return_type = method.response_type.as_deref().unwrap_or("void");
 
             output.push_str(&format!("  /** {} */\n", method.description));
-            output.push_str(&format!("  async {}({}): Promise<{}> {{\n",
-                method.name, params, return_type));
+            output.push_str(&format!(
+                "  async {}({}): Promise<{}> {{\n",
+                method.name, params, return_type
+            ));
 
             let path = self.interpolate_path_ts(&method.path, &method.params);
             if method.request_type.is_some() {
@@ -509,7 +524,11 @@ impl SdkGenerator {
 
             for fld in &type_def.fields {
                 let py_type = self.field_type_to_py(&fld.field_type);
-                let optional = if fld.optional { format!("Optional[{}]", py_type) } else { py_type };
+                let optional = if fld.optional {
+                    format!("Optional[{}]", py_type)
+                } else {
+                    py_type
+                };
                 let default = if fld.optional { " = None" } else { "" };
                 output.push_str(&format!("    {}: {}{}\n", fld.name, optional, default));
             }
@@ -525,7 +544,9 @@ impl SdkGenerator {
         output.push_str("        self.base_url = base_url\n");
         output.push_str("        self.api_key = api_key\n\n");
 
-        output.push_str("    def _request(self, method: str, path: str, body: Optional[Dict] = None) -> Any:\n");
+        output.push_str(
+            "    def _request(self, method: str, path: str, body: Optional[Dict] = None) -> Any:\n",
+        );
         output.push_str("        headers = {'Content-Type': 'application/json'}\n");
         output.push_str("        if self.api_key:\n");
         output.push_str("            headers['X-API-Key'] = self.api_key\n\n");
@@ -543,9 +564,14 @@ impl SdkGenerator {
             let params = self.method_params_py(method);
             let return_type = method.response_type.as_deref().unwrap_or("None");
 
-            output.push_str(&format!("    def {}(self{}) -> {}:\n",
+            output.push_str(&format!(
+                "    def {}(self{}) -> {}:\n",
                 to_snake_case(&method.name),
-                if params.is_empty() { String::new() } else { format!(", {}", params) },
+                if params.is_empty() {
+                    String::new()
+                } else {
+                    format!(", {}", params)
+                },
                 self.response_type_to_py(return_type)
             ));
 
@@ -594,11 +620,13 @@ impl SdkGenerator {
 
             for fld in &type_def.fields {
                 let go_type = self.field_type_to_go(&fld.field_type, fld.optional);
-                let json_tag = format!("`json:\"{}{}\"`",
+                let json_tag = format!(
+                    "`json:\"{}{}\"`",
                     fld.name,
                     if fld.optional { ",omitempty" } else { "" }
                 );
-                output.push_str(&format!("\t{} {} {}\n",
+                output.push_str(&format!(
+                    "\t{} {} {}\n",
                     to_pascal_case(&fld.name),
                     go_type,
                     json_tag
@@ -666,9 +694,14 @@ impl SdkGenerator {
             let params = self.method_params_go(method);
             let return_type = self.response_type_to_go(method.response_type.as_deref());
 
-            output.push_str(&format!("func (c *Client) {}(ctx context.Context{}) {} {{\n",
+            output.push_str(&format!(
+                "func (c *Client) {}(ctx context.Context{}) {} {{\n",
                 func_name,
-                if params.is_empty() { String::new() } else { format!(", {}", params) },
+                if params.is_empty() {
+                    String::new()
+                } else {
+                    format!(", {}", params)
+                },
                 return_type
             ));
 
@@ -680,19 +713,27 @@ impl SdkGenerator {
                 output.push('\n');
 
                 if method.request_type.is_some() {
-                    output.push_str(&format!("\terr := c.request(ctx, \"{}\", {}, body, &result)\n",
-                        method.http_method, path));
+                    output.push_str(&format!(
+                        "\terr := c.request(ctx, \"{}\", {}, body, &result)\n",
+                        method.http_method, path
+                    ));
                 } else {
-                    output.push_str(&format!("\terr := c.request(ctx, \"{}\", {}, nil, &result)\n",
-                        method.http_method, path));
+                    output.push_str(&format!(
+                        "\terr := c.request(ctx, \"{}\", {}, nil, &result)\n",
+                        method.http_method, path
+                    ));
                 }
                 output.push_str("\treturn result, err\n");
             } else if method.request_type.is_some() {
-                output.push_str(&format!("\treturn c.request(ctx, \"{}\", {}, body, nil)\n",
-                    method.http_method, path));
+                output.push_str(&format!(
+                    "\treturn c.request(ctx, \"{}\", {}, body, nil)\n",
+                    method.http_method, path
+                ));
             } else {
-                output.push_str(&format!("\treturn c.request(ctx, \"{}\", {}, nil, nil)\n",
-                    method.http_method, path));
+                output.push_str(&format!(
+                    "\treturn c.request(ctx, \"{}\", {}, nil, nil)\n",
+                    method.http_method, path
+                ));
             }
 
             output.push_str("}\n\n");
@@ -734,7 +775,8 @@ impl SdkGenerator {
             let java_return = self.response_type_to_java(return_type);
 
             output.push_str(&format!("    /** {} */\n", method.description));
-            output.push_str(&format!("    public {} {}({}) throws Exception {{\n",
+            output.push_str(&format!(
+                "    public {} {}({}) throws Exception {{\n",
                 java_return,
                 method.name,
                 self.method_params_java(method)
@@ -796,7 +838,11 @@ impl SdkGenerator {
                 } else {
                     rust_type
                 };
-                output.push_str(&format!("    pub {}: {},\n", to_snake_case(&fld.name), field_type));
+                output.push_str(&format!(
+                    "    pub {}: {},\n",
+                    to_snake_case(&fld.name),
+                    field_type
+                ));
             }
 
             output.push_str("}\n\n");
@@ -904,7 +950,10 @@ impl SdkGenerator {
         }
 
         if method.request_type.is_some() {
-            params.push(format!("body *{}", method.request_type.as_ref().unwrap().replace("[]", "")));
+            params.push(format!(
+                "body *{}",
+                method.request_type.as_ref().unwrap().replace("[]", "")
+            ));
         }
 
         params.join(", ")
@@ -920,7 +969,10 @@ impl SdkGenerator {
         }
 
         if let Some(ref rt) = method.request_type {
-            params.push(format!("{} body", rt.replace("[]", "List<>").replace("<>", "")));
+            params.push(format!(
+                "{} body",
+                rt.replace("[]", "List<>").replace("<>", "")
+            ));
         }
 
         params.join(", ")
@@ -937,7 +989,8 @@ impl SdkGenerator {
     }
 
     fn interpolate_path_go(&self, path: &str, _params: &[ParamDef]) -> String {
-        let formatted = path.replace("{collection}", "\" + collection + \"")
+        let formatted = path
+            .replace("{collection}", "\" + collection + \"")
             .replace("{id}", "\" + id + \"");
         format!("\"{}\"", formatted).replace(" + \"\"", "")
     }
@@ -961,7 +1014,7 @@ impl SdkGenerator {
                 } else {
                     format!("({}, error)", t)
                 }
-            }
+            },
             None => "error".to_string(),
         }
     }
diff --git a/src/semantic_cache.rs b/src/semantic_cache.rs
index 4c262cb..b3784f3 100644
--- a/src/semantic_cache.rs
+++ b/src/semantic_cache.rs
@@ -139,9 +139,10 @@ impl<V: Clone> SemanticCache<V> {
             for (idx, entry) in bucket.iter().enumerate() {
                 // Check TTL
                 if let Some(ttl) = self.ttl
-                    && now.duration_since(entry.inserted_at) > ttl {
-                        continue; // Skip expired entries
-                    }
+                    && now.duration_since(entry.inserted_at) > ttl
+                {
+                    continue; // Skip expired entries
+                }
 
                 // Calculate similarity
                 let similarity = Self::cosine_similarity(query, &entry.query);
@@ -151,8 +152,8 @@ impl<V: Clone> SemanticCache<V> {
                         None => best_match = Some((idx, similarity)),
                         Some((_, prev_sim)) if similarity > prev_sim => {
                             best_match = Some((idx, similarity));
-                        }
-                        _ => {}
+                        },
+                        _ => {},
                     }
                 }
             }
@@ -181,9 +182,10 @@ impl<V: Clone> SemanticCache<V> {
             for entry in bucket {
                 // Check TTL
                 if let Some(ttl) = self.ttl
-                    && now.duration_since(entry.inserted_at) > ttl {
-                        continue;
-                    }
+                    && now.duration_since(entry.inserted_at) > ttl
+                {
+                    continue;
+                }
 
                 let similarity = Self::cosine_similarity(query, &entry.query);
                 if similarity >= self.similarity_threshold {
@@ -270,12 +272,13 @@ impl<V: Clone> SemanticCache<V> {
 
         // Remove the LRU entry
         if let Some(bucket_key) = oldest_bucket
-            && let Some(bucket) = self.entries.get_mut(&bucket_key) {
-                bucket.remove(oldest_idx);
-                if bucket.is_empty() {
-                    self.entries.remove(&bucket_key);
-                }
+            && let Some(bucket) = self.entries.get_mut(&bucket_key)
+        {
+            bucket.remove(oldest_idx);
+            if bucket.is_empty() {
+                self.entries.remove(&bucket_key);
             }
+        }
     }
 
     /// Hash vector to bucket key (quantized hashing)
diff --git a/src/server/admin.rs b/src/server/admin.rs
index 7f128d6..87ed106 100644
--- a/src/server/admin.rs
+++ b/src/server/admin.rs
@@ -211,7 +211,9 @@ impl VecStoreAdminService for AdminService {
     ) -> Result<Response<GetAggregateStatsResponse>, Status> {
         let manager = self.manager.read().await;
 
-        let stats = manager.get_aggregate_stats();
+        let stats = manager
+            .get_aggregate_stats()
+            .map_err(|e| Status::internal(format!("Failed to collect aggregate stats: {e}")))?;
 
         Ok(Response::new(GetAggregateStatsResponse {
             total_namespaces: stats.total_namespaces as i32,
diff --git a/src/server/admin_http.rs b/src/server/admin_http.rs
index 917cf56..2d80a73 100644
--- a/src/server/admin_http.rs
+++ b/src/server/admin_http.rs
@@ -3,11 +3,11 @@
 use crate::namespace::{NamespaceQuotas, NamespaceStatus};
 use crate::namespace_manager::NamespaceManager;
 use axum::{
+    Json, Router,
     extract::{Path, State},
     http::StatusCode,
     response::{IntoResponse, Response},
     routing::{delete, get, post, put},
-    Json, Router,
 };
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -256,8 +256,8 @@ async fn update_status(
             return Err(AppError::BadRequest(format!(
                 "Invalid status: {}",
                 req.status
-            )))
-        }
+            )));
+        },
     };
 
     let manager = server.manager.write().await;
@@ -318,7 +318,9 @@ async fn get_aggregate_stats(
 ) -> Result<Json<AggregateStatsDto>, AppError> {
     let manager = server.manager.read().await;
 
-    let stats = manager.get_aggregate_stats();
+    let stats = manager
+        .get_aggregate_stats()
+        .map_err(|e| AppError::Internal(e.to_string()))?;
 
     Ok(Json(AggregateStatsDto {
         total_namespaces: stats.total_namespaces,
@@ -359,24 +361,32 @@ impl IntoResponse for AppError {
 // Health checks
 // ============================================================================
 
-async fn health_check(State(server): State<AdminHttpServer>) -> Json<serde_json::Value> {
+async fn health_check(
+    State(server): State<AdminHttpServer>,
+) -> Result<Json<serde_json::Value>, AppError> {
     let manager = server.manager.read().await;
-    let stats = manager.get_aggregate_stats();
+    let stats = manager
+        .get_aggregate_stats()
+        .map_err(|e| AppError::Internal(e.to_string()))?;
 
-    Json(serde_json::json!({
+    Ok(Json(serde_json::json!({
         "status": "healthy",
         "mode": "multi-tenant",
         "total_namespaces": stats.total_namespaces,
         "active_namespaces": stats.active_namespaces,
-    }))
+    })))
 }
 
-async fn ready_check(State(server): State<AdminHttpServer>) -> Json<serde_json::Value> {
+async fn ready_check(
+    State(server): State<AdminHttpServer>,
+) -> Result<Json<serde_json::Value>, AppError> {
     let manager = server.manager.read().await;
-    let stats = manager.get_aggregate_stats();
+    let stats = manager
+        .get_aggregate_stats()
+        .map_err(|e| AppError::Internal(e.to_string()))?;
 
-    Json(serde_json::json!({
+    Ok(Json(serde_json::json!({
         "ready": true,
         "total_namespaces": stats.total_namespaces,
-    }))
+    })))
 }
diff --git a/src/server/grpc.rs b/src/server/grpc.rs
index b5c72cb..89395f3 100644
--- a/src/server/grpc.rs
+++ b/src/server/grpc.rs
@@ -84,7 +84,7 @@ impl pb::vec_store_service_server::VecStoreService for VecStoreGrpcServer {
                         Ok(_) => inserted += 1,
                         Err(e) => errors.push(format!("{}: {}", upsert_req.id, e)),
                     }
-                }
+                },
                 Err(e) => errors.push(format!("{}: invalid metadata: {}", upsert_req.id, e)),
             }
         }
diff --git a/src/server/http.rs b/src/server/http.rs
index 5a110ed..85a218a 100644
--- a/src/server/http.rs
+++ b/src/server/http.rs
@@ -2,14 +2,14 @@
 
 use crate::store::VecStore;
 use axum::{
+    Json, Router,
     extract::{
-        ws::{Message, WebSocket, WebSocketUpgrade},
         Path, State,
+        ws::{Message, WebSocket, WebSocketUpgrade},
     },
     http::StatusCode,
     response::{IntoResponse, Response},
     routing::{delete, get, post},
-    Json, Router,
 };
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -435,7 +435,7 @@ async fn batch_execute(
                     id,
                     metadata: crate::store::Metadata { fields: metadata },
                 }
-            }
+            },
         })
         .collect();
 
@@ -834,7 +834,7 @@ async fn handle_query_stream(mut socket: WebSocket, server: VecStoreHttpServer)
             Err(e) => {
                 tracing::error!("WebSocket error: {}", e);
                 break;
-            }
+            },
         };
 
         match msg {
@@ -860,7 +860,7 @@ async fn handle_query_stream(mut socket: WebSocket, server: VecStoreHttpServer)
                                         break;
                                     }
                                     continue;
-                                }
+                                },
                             }
                         } else {
                             None
@@ -893,7 +893,7 @@ async fn handle_query_stream(mut socket: WebSocket, server: VecStoreHttpServer)
                                         Err(e) => {
                                             tracing::error!("Failed to serialize result: {}", e);
                                             break;
-                                        }
+                                        },
                                     };
 
                                     if socket
@@ -921,7 +921,7 @@ async fn handle_query_stream(mut socket: WebSocket, server: VecStoreHttpServer)
                                 {
                                     break;
                                 }
-                            }
+                            },
                             Err(e) => {
                                 let error_msg = serde_json::json!({
                                     "error": format!("Query failed: {}", e)
@@ -933,9 +933,9 @@ async fn handle_query_stream(mut socket: WebSocket, server: VecStoreHttpServer)
                                 {
                                     break;
                                 }
-                            }
+                            },
                         }
-                    }
+                    },
                     Err(e) => {
                         let error_msg = serde_json::json!({
                             "error": format!("Invalid query request: {}", e)
@@ -947,15 +947,15 @@ async fn handle_query_stream(mut socket: WebSocket, server: VecStoreHttpServer)
                         {
                             break;
                         }
-                    }
+                    },
                 }
-            }
+            },
             Message::Close(_) => {
                 break;
-            }
+            },
             _ => {
                 // Ignore other message types (binary, ping, pong)
-            }
+            },
         }
     }
 }
diff --git a/src/server/metrics.rs b/src/server/metrics.rs
index abc2d55..8fc107d 100644
--- a/src/server/metrics.rs
+++ b/src/server/metrics.rs
@@ -2,11 +2,11 @@
 //!
 //! Exposes metrics at /metrics endpoint for Prometheus scraping.
 
-use std::sync::LazyLock;
 use prometheus::{
-    register_counter_vec, register_gauge, register_histogram_vec, CounterVec, Encoder, Gauge,
-    HistogramVec, TextEncoder,
+    CounterVec, Encoder, Gauge, HistogramVec, TextEncoder, register_counter_vec, register_gauge,
+    register_histogram_vec,
 };
+use std::sync::LazyLock;
 
 /// Total number of requests by endpoint
 pub static REQUEST_COUNTER: LazyLock<CounterVec> = LazyLock::new(|| {
@@ -24,7 +24,9 @@ pub static REQUEST_DURATION: LazyLock<HistogramVec> = LazyLock::new(|| {
         "vecstore_request_duration_seconds",
         "Request duration in seconds",
         &["endpoint", "method"],
-        vec![0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0]
+        vec![
+            0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0
+        ]
     )
     .unwrap()
 });
@@ -90,20 +92,12 @@ pub static ACTIVE_VECTORS: LazyLock<Gauge> = LazyLock::new(|| {
 
 /// Deleted vectors
 pub static DELETED_VECTORS: LazyLock<Gauge> = LazyLock::new(|| {
-    register_gauge!(
-        "vecstore_vectors_deleted",
-        "Number of soft-deleted vectors"
-    )
-    .unwrap()
+    register_gauge!("vecstore_vectors_deleted", "Number of soft-deleted vectors").unwrap()
 });
 
 /// Database dimension
 pub static DIMENSION: LazyLock<Gauge> = LazyLock::new(|| {
-    register_gauge!(
-        "vecstore_dimension",
-        "Vector dimension of the database"
-    )
-    .unwrap()
+    register_gauge!("vecstore_dimension", "Vector dimension of the database").unwrap()
 });
 
 /// Errors by type
diff --git a/src/server/types.rs b/src/server/types.rs
index b8e4602..092c021 100644
--- a/src/server/types.rs
+++ b/src/server/types.rs
@@ -21,14 +21,14 @@ pub fn pb_value_to_json(value: &pb::Value) -> Result<serde_json::Value> {
         Some(Kind::ArrayValue(arr)) => {
             let values: Result<Vec<_>> = arr.values.iter().map(pb_value_to_json).collect();
             Ok(serde_json::Value::Array(values?))
-        }
+        },
         Some(Kind::ObjectValue(obj)) => {
             let mut map = serde_json::Map::new();
             for (k, v) in &obj.fields {
                 map.insert(k.clone(), pb_value_to_json(v)?);
             }
             Ok(serde_json::Value::Object(map))
-        }
+        },
         Some(Kind::NullValue(_)) => Ok(serde_json::Value::Null),
         None => Ok(serde_json::Value::Null),
     }
@@ -45,14 +45,14 @@ pub fn json_to_pb_value(value: &serde_json::Value) -> pb::Value {
         serde_json::Value::Array(arr) => {
             let values = arr.iter().map(json_to_pb_value).collect();
             Some(Kind::ArrayValue(pb::ArrayValue { values }))
-        }
+        },
         serde_json::Value::Object(obj) => {
             let fields = obj
                 .iter()
                 .map(|(k, v)| (k.clone(), json_to_pb_value(v)))
                 .collect();
             Some(Kind::ObjectValue(pb::ObjectValue { fields }))
-        }
+        },
         serde_json::Value::Null => Some(Kind::NullValue(pb::NullValue::NullValue as i32)),
     };
 
diff --git a/src/serverless.rs b/src/serverless.rs
index e4d4b39..76157de 100644
--- a/src/serverless.rs
+++ b/src/serverless.rs
@@ -27,10 +27,13 @@
 //! let results = cluster.query(&query_vec, 10).await?;
 //! ```
 
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::sync::{RwLock, atomic::{AtomicU64, AtomicUsize, Ordering}};
+use std::sync::{
+    RwLock,
+    atomic::{AtomicU64, AtomicUsize, Ordering},
+};
 use std::time::{Duration, Instant};
-use serde::{Deserialize, Serialize};
 
 use crate::error::Result;
 
@@ -161,7 +164,9 @@ impl Autoscaler {
 
     /// Record current QPS
     pub fn record_qps(&self, qps: f64) {
-        let Ok(mut history) = self.qps_history.write() else { return; };
+        let Ok(mut history) = self.qps_history.write() else {
+            return;
+        };
         let now = Instant::now();
 
         // Keep last 5 minutes of data
@@ -170,11 +175,15 @@ impl Autoscaler {
 
         // Update hourly pattern for predictive scaling
         if self.config.predictive_scaling {
-            let Ok(duration) = std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH) else { return; };
+            let Ok(duration) = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH)
+            else {
+                return;
+            };
             let hour = (duration.as_secs() / 3600 % 24) as usize;
 
-            let Ok(mut patterns) = self.hourly_patterns.write() else { return; };
+            let Ok(mut patterns) = self.hourly_patterns.write() else {
+                return;
+            };
             // Exponential moving average
             patterns[hour] = patterns[hour] * 0.9 + qps * 0.1;
         }
@@ -182,11 +191,14 @@ impl Autoscaler {
 
     /// Get average QPS over last N seconds
     fn avg_qps(&self, seconds: u64) -> f64 {
-        let Ok(history) = self.qps_history.read() else { return 0.0; };
+        let Ok(history) = self.qps_history.read() else {
+            return 0.0;
+        };
         let now = Instant::now();
         let cutoff = Duration::from_secs(seconds);
 
-        let recent: Vec<f64> = history.iter()
+        let recent: Vec<f64> = history
+            .iter()
             .filter(|(t, _)| now.duration_since(*t) < cutoff)
             .map(|(_, q)| *q)
             .collect();
@@ -204,11 +216,15 @@ impl Autoscaler {
             return self.avg_qps(60);
         }
 
-        let Ok(duration) = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH) else { return self.avg_qps(60); };
+        let Ok(duration) = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH)
+        else {
+            return self.avg_qps(60);
+        };
         let next_hour = ((duration.as_secs() / 3600 + 1) % 24) as usize;
 
-        let Ok(patterns) = self.hourly_patterns.read() else { return self.avg_qps(60); };
+        let Ok(patterns) = self.hourly_patterns.read() else {
+            return self.avg_qps(60);
+        };
         patterns[next_hour]
     }
 
@@ -234,11 +250,14 @@ impl Autoscaler {
             ScalingDecision::ScaleUp(desired - current_replicas)
         } else if desired < current_replicas {
             // Check scale down delay
-            let Ok(last_scale) = self.last_scale_down.read() else { return ScalingDecision::NoChange; };
+            let Ok(last_scale) = self.last_scale_down.read() else {
+                return ScalingDecision::NoChange;
+            };
             if let Some(last) = *last_scale
-                && last.elapsed() < Duration::from_secs(self.config.scale_down_delay_secs) {
-                    return ScalingDecision::NoChange;
-                }
+                && last.elapsed() < Duration::from_secs(self.config.scale_down_delay_secs)
+            {
+                return ScalingDecision::NoChange;
+            }
             ScalingDecision::ScaleDown(current_replicas - desired)
         } else {
             ScalingDecision::NoChange
@@ -247,7 +266,9 @@ impl Autoscaler {
 
     /// Mark scale down event
     pub fn mark_scale_down(&self) {
-        let Ok(mut guard) = self.last_scale_down.write() else { return; };
+        let Ok(mut guard) = self.last_scale_down.write() else {
+            return;
+        };
         *guard = Some(Instant::now());
     }
 }
@@ -296,7 +317,8 @@ impl LoadBalancer {
             return None;
         }
 
-        let ready: Vec<_> = replicas.iter()
+        let ready: Vec<_> = replicas
+            .iter()
             .filter(|r| r.state == ReplicaState::Ready)
             .collect();
 
@@ -308,27 +330,34 @@ impl LoadBalancer {
             LoadBalanceStrategy::RoundRobin => {
                 let idx = self.rr_counter.fetch_add(1, Ordering::SeqCst) as usize % ready.len();
                 Some(ready[idx].id.clone())
-            }
+            },
             LoadBalanceStrategy::LeastConnections => {
-                let Ok(conns) = self.connections.read() else { return None; };
-                ready.iter()
+                let Ok(conns) = self.connections.read() else {
+                    return None;
+                };
+                ready
+                    .iter()
                     .min_by_key(|r| {
-                        conns.get(&r.id)
+                        conns
+                            .get(&r.id)
                             .map(|c| c.load(Ordering::SeqCst))
                             .unwrap_or(0)
                     })
                     .map(|r| r.id.clone())
-            }
+            },
             LoadBalanceStrategy::LatencyAware => {
-                let Ok(lats) = self.latencies.read() else { return None; };
-                ready.iter()
+                let Ok(lats) = self.latencies.read() else {
+                    return None;
+                };
+                ready
+                    .iter()
                     .min_by(|a, b| {
                         let la = lats.get(&a.id).unwrap_or(&f64::MAX);
                         let lb = lats.get(&b.id).unwrap_or(&f64::MAX);
                         la.total_cmp(lb)
                     })
                     .map(|r| r.id.clone())
-            }
+            },
             LoadBalanceStrategy::WeightedRandom => {
                 // Simple random for now
                 use std::collections::hash_map::DefaultHasher;
@@ -338,14 +367,17 @@ impl LoadBalancer {
                 Instant::now().hash(&mut hasher);
                 let idx = hasher.finish() as usize % ready.len();
                 Some(ready[idx].id.clone())
-            }
+            },
         }
     }
 
     /// Record connection start
     pub fn connection_start(&self, replica_id: &str) {
-        let Ok(mut conns) = self.connections.write() else { return; };
-        conns.entry(replica_id.to_string())
+        let Ok(mut conns) = self.connections.write() else {
+            return;
+        };
+        conns
+            .entry(replica_id.to_string())
             .or_insert_with(|| AtomicUsize::new(0))
             .fetch_add(1, Ordering::SeqCst);
     }
@@ -353,14 +385,18 @@ impl LoadBalancer {
     /// Record connection end with latency
     pub fn connection_end(&self, replica_id: &str, latency_ms: f64) {
         {
-            let Ok(conns) = self.connections.read() else { return; };
+            let Ok(conns) = self.connections.read() else {
+                return;
+            };
             if let Some(c) = conns.get(replica_id) {
                 c.fetch_sub(1, Ordering::SeqCst);
             }
         }
 
         // Update latency with exponential moving average
-        let Ok(mut lats) = self.latencies.write() else { return; };
+        let Ok(mut lats) = self.latencies.write() else {
+            return;
+        };
         let entry = lats.entry(replica_id.to_string()).or_insert(latency_ms);
         *entry = *entry * 0.9 + latency_ms * 0.1;
     }
@@ -405,14 +441,17 @@ impl ServerlessCluster {
 
     /// Get current replica count
     pub fn replica_count(&self) -> usize {
-        let Ok(replicas) = self.replicas.read() else { return 0; };
+        let Ok(replicas) = self.replicas.read() else {
+            return 0;
+        };
         replicas.len()
     }
 
     /// Scale to target replicas
     pub fn scale_to(&self, target: usize) -> Result<()> {
-        let mut replicas = self.replicas.write()
-            .map_err(|_| crate::error::VecStoreError::LockError("Failed to acquire replicas write lock".into()))?;
+        let mut replicas = self.replicas.write().map_err(|_| {
+            crate::error::VecStoreError::LockError("Failed to acquire replicas write lock".into())
+        })?;
         let current = replicas.len();
 
         if target > current {
@@ -440,7 +479,9 @@ impl ServerlessCluster {
 
     /// Simulate replica becoming ready
     pub fn mark_replica_ready(&self, replica_id: &str) {
-        let Ok(mut replicas) = self.replicas.write() else { return; };
+        let Ok(mut replicas) = self.replicas.write() else {
+            return;
+        };
         if let Some(r) = replicas.iter_mut().find(|r| r.id == replica_id) {
             r.state = ReplicaState::Ready;
         }
@@ -448,7 +489,9 @@ impl ServerlessCluster {
 
     /// Remove stopped replicas
     pub fn cleanup_stopped(&self) {
-        let Ok(mut replicas) = self.replicas.write() else { return; };
+        let Ok(mut replicas) = self.replicas.write() else {
+            return;
+        };
         replicas.retain(|r| r.state != ReplicaState::Stopped);
     }
 
@@ -458,7 +501,9 @@ impl ServerlessCluster {
 
         // Update cost
         {
-            let Ok(mut cost) = self.total_cost.write() else { return; };
+            let Ok(mut cost) = self.total_cost.write() else {
+                return;
+            };
             *cost += self.config.cost_per_query;
         }
 
@@ -487,13 +532,16 @@ impl ServerlessCluster {
 
     /// Select replica for query
     pub fn select_replica(&self) -> Option<String> {
-        let Ok(replicas) = self.replicas.read() else { return None; };
+        let Ok(replicas) = self.replicas.read() else {
+            return None;
+        };
         self.load_balancer.select(&replicas)
     }
 
     /// Get cluster statistics
     pub fn stats(&self) -> ServerlessStats {
-        let storage_gb = self.storage_bytes.load(Ordering::SeqCst) as f64 / (1024.0 * 1024.0 * 1024.0);
+        let storage_gb =
+            self.storage_bytes.load(Ordering::SeqCst) as f64 / (1024.0 * 1024.0 * 1024.0);
         let total_queries = self.query_count.load(Ordering::SeqCst);
 
         let Ok(replicas) = self.replicas.read() else {
@@ -517,17 +565,27 @@ impl ServerlessCluster {
                 total_queries,
                 total_cost: *total_cost,
                 storage_gb,
-                estimated_monthly_cost: *total_cost * 30.0 * 24.0 + storage_gb * self.config.cost_per_gb_month,
+                estimated_monthly_cost: *total_cost * 30.0 * 24.0
+                    + storage_gb * self.config.cost_per_gb_month,
             };
         };
 
-        let ready = replicas.iter().filter(|r| r.state == ReplicaState::Ready).count();
+        let ready = replicas
+            .iter()
+            .filter(|r| r.state == ReplicaState::Ready)
+            .count();
         let Ok(total_cost) = self.total_cost.read() else {
             return ServerlessStats {
                 total_replicas: replicas.len(),
                 ready_replicas: ready,
-                starting_replicas: replicas.iter().filter(|r| r.state == ReplicaState::Starting).count(),
-                draining_replicas: replicas.iter().filter(|r| r.state == ReplicaState::Draining).count(),
+                starting_replicas: replicas
+                    .iter()
+                    .filter(|r| r.state == ReplicaState::Starting)
+                    .count(),
+                draining_replicas: replicas
+                    .iter()
+                    .filter(|r| r.state == ReplicaState::Draining)
+                    .count(),
                 total_queries,
                 total_cost: 0.0,
                 storage_gb,
@@ -538,8 +596,14 @@ impl ServerlessCluster {
         ServerlessStats {
             total_replicas: replicas.len(),
             ready_replicas: ready,
-            starting_replicas: replicas.iter().filter(|r| r.state == ReplicaState::Starting).count(),
-            draining_replicas: replicas.iter().filter(|r| r.state == ReplicaState::Draining).count(),
+            starting_replicas: replicas
+                .iter()
+                .filter(|r| r.state == ReplicaState::Starting)
+                .count(),
+            draining_replicas: replicas
+                .iter()
+                .filter(|r| r.state == ReplicaState::Draining)
+                .count(),
             total_queries,
             total_cost: *total_cost,
             storage_gb,
@@ -634,21 +698,29 @@ impl ColdStartOptimizer {
 
     /// Create snapshot for fast restore
     pub fn create_snapshot(&self, data: Vec<u8>) {
-        let Ok(mut snapshot) = self.snapshot_data.write() else { return; };
+        let Ok(mut snapshot) = self.snapshot_data.write() else {
+            return;
+        };
         *snapshot = Some(data);
-        let Ok(mut last) = self.last_snapshot.write() else { return; };
+        let Ok(mut last) = self.last_snapshot.write() else {
+            return;
+        };
         *last = Some(Instant::now());
     }
 
     /// Get snapshot for restore
     pub fn get_snapshot(&self) -> Option<Vec<u8>> {
-        let Ok(snapshot) = self.snapshot_data.read() else { return None; };
+        let Ok(snapshot) = self.snapshot_data.read() else {
+            return None;
+        };
         snapshot.clone()
     }
 
     /// Check if snapshot is fresh enough
     pub fn is_snapshot_valid(&self, max_age_secs: u64) -> bool {
-        let Ok(last_snapshot) = self.last_snapshot.read() else { return false; };
+        let Ok(last_snapshot) = self.last_snapshot.read() else {
+            return false;
+        };
         if let Some(last) = *last_snapshot {
             last.elapsed() < Duration::from_secs(max_age_secs)
         } else {
@@ -693,7 +765,10 @@ mod tests {
         let autoscaler = Autoscaler::new(config);
 
         // No load -> scale to min
-        assert!(matches!(autoscaler.decide(5), ScalingDecision::ScaleDown(_)));
+        assert!(matches!(
+            autoscaler.decide(5),
+            ScalingDecision::ScaleDown(_)
+        ));
 
         // Record high QPS
         autoscaler.record_qps(500.0);
@@ -715,8 +790,8 @@ mod tests {
         let cluster = ServerlessCluster::new(config).unwrap();
 
         let estimate = cluster.billing_estimate(1_000_000, 10.0);
-        assert_eq!(estimate.query_cost, 10.0);  // 1M * $0.00001
-        assert_eq!(estimate.storage_cost, 2.5);  // 10GB * $0.25
+        assert_eq!(estimate.query_cost, 10.0); // 1M * $0.00001
+        assert_eq!(estimate.storage_cost, 2.5); // 10GB * $0.25
         assert_eq!(estimate.total_monthly_cost, 12.5);
     }
 }
diff --git a/src/simd.rs b/src/simd.rs
index 165ef27..7925885 100644
--- a/src/simd.rs
+++ b/src/simd.rs
@@ -116,38 +116,40 @@ unsafe fn euclidean_distance_avx2(a: &[f32], b: &[f32]) -> f32 {
 #[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
 #[inline]
 #[target_feature(enable = "sse2")]
-unsafe fn euclidean_distance_sse2(a: &[f32], b: &[f32]) -> f32 { unsafe {
-    let len = a.len();
-    let mut sum = _mm_setzero_ps();
-    let mut i = 0;
-
-    // Process 4 floats at a time
-    while i + 4 <= len {
-        let va = _mm_loadu_ps(a.as_ptr().add(i));
-        let vb = _mm_loadu_ps(b.as_ptr().add(i));
-        let diff = _mm_sub_ps(va, vb);
-        let squared = _mm_mul_ps(diff, diff);
-        sum = _mm_add_ps(sum, squared);
-        i += 4;
-    }
+unsafe fn euclidean_distance_sse2(a: &[f32], b: &[f32]) -> f32 {
+    unsafe {
+        let len = a.len();
+        let mut sum = _mm_setzero_ps();
+        let mut i = 0;
+
+        // Process 4 floats at a time
+        while i + 4 <= len {
+            let va = _mm_loadu_ps(a.as_ptr().add(i));
+            let vb = _mm_loadu_ps(b.as_ptr().add(i));
+            let diff = _mm_sub_ps(va, vb);
+            let squared = _mm_mul_ps(diff, diff);
+            sum = _mm_add_ps(sum, squared);
+            i += 4;
+        }
 
-    // Horizontal sum
-    // _MM_SHUFFLE(2, 3, 0, 1) = 0b10110001 = 177
-    let sum_shuf = _mm_shuffle_ps(sum, sum, 0b10110001);
-    let sums = _mm_add_ps(sum, sum_shuf);
-    let sums_shuf = _mm_movehl_ps(sums, sums);
-    let result_ss = _mm_add_ss(sums, sums_shuf);
-    let mut result = _mm_cvtss_f32(result_ss);
+        // Horizontal sum
+        // _MM_SHUFFLE(2, 3, 0, 1) = 0b10110001 = 177
+        let sum_shuf = _mm_shuffle_ps(sum, sum, 0b10110001);
+        let sums = _mm_add_ps(sum, sum_shuf);
+        let sums_shuf = _mm_movehl_ps(sums, sums);
+        let result_ss = _mm_add_ss(sums, sums_shuf);
+        let mut result = _mm_cvtss_f32(result_ss);
+
+        // Handle remaining elements
+        while i < len {
+            let diff = a[i] - b[i];
+            result += diff * diff;
+            i += 1;
+        }
 
-    // Handle remaining elements
-    while i < len {
-        let diff = a[i] - b[i];
-        result += diff * diff;
-        i += 1;
+        result.sqrt()
     }
-
-    result.sqrt()
-}}
+}
 
 /// ARM NEON implementation (processes 4 floats at once)
 #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
@@ -265,33 +267,35 @@ unsafe fn dot_product_avx2(a: &[f32], b: &[f32]) -> f32 {
 #[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
 #[inline]
 #[target_feature(enable = "sse2")]
-unsafe fn dot_product_sse2(a: &[f32], b: &[f32]) -> f32 { unsafe {
-    let len = a.len();
-    let mut sum = _mm_setzero_ps();
-    let mut i = 0;
+unsafe fn dot_product_sse2(a: &[f32], b: &[f32]) -> f32 {
+    unsafe {
+        let len = a.len();
+        let mut sum = _mm_setzero_ps();
+        let mut i = 0;
+
+        while i + 4 <= len {
+            let va = _mm_loadu_ps(a.as_ptr().add(i));
+            let vb = _mm_loadu_ps(b.as_ptr().add(i));
+            let prod = _mm_mul_ps(va, vb);
+            sum = _mm_add_ps(sum, prod);
+            i += 4;
+        }
 
-    while i + 4 <= len {
-        let va = _mm_loadu_ps(a.as_ptr().add(i));
-        let vb = _mm_loadu_ps(b.as_ptr().add(i));
-        let prod = _mm_mul_ps(va, vb);
-        sum = _mm_add_ps(sum, prod);
-        i += 4;
-    }
+        // _MM_SHUFFLE(2, 3, 0, 1) = 0b10110001 = 177
+        let sum_shuf = _mm_shuffle_ps(sum, sum, 0b10110001);
+        let sums = _mm_add_ps(sum, sum_shuf);
+        let sums_shuf = _mm_movehl_ps(sums, sums);
+        let result_ss = _mm_add_ss(sums, sums_shuf);
+        let mut result = _mm_cvtss_f32(result_ss);
 
-    // _MM_SHUFFLE(2, 3, 0, 1) = 0b10110001 = 177
-    let sum_shuf = _mm_shuffle_ps(sum, sum, 0b10110001);
-    let sums = _mm_add_ps(sum, sum_shuf);
-    let sums_shuf = _mm_movehl_ps(sums, sums);
-    let result_ss = _mm_add_ss(sums, sums_shuf);
-    let mut result = _mm_cvtss_f32(result_ss);
+        while i < len {
+            result += a[i] * b[i];
+            i += 1;
+        }
 
-    while i < len {
-        result += a[i] * b[i];
-        i += 1;
+        result
     }
-
-    result
-}}
+}
 
 /// Calculate vector magnitude (L2 norm) using SIMD
 #[inline]
@@ -395,40 +399,42 @@ unsafe fn manhattan_distance_avx2(a: &[f32], b: &[f32]) -> f32 {
 #[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
 #[inline]
 #[target_feature(enable = "sse2")]
-unsafe fn manhattan_distance_sse2(a: &[f32], b: &[f32]) -> f32 { unsafe {
-    let len = a.len();
-    let mut sum = _mm_setzero_ps();
-    let mut i = 0;
-
-    // Sign bit mask for abs()
-    let sign_mask = _mm_set1_ps(f32::from_bits(0x7FFF_FFFF));
-
-    // Process 4 floats at a time
-    while i + 4 <= len {
-        let va = _mm_loadu_ps(a.as_ptr().add(i));
-        let vb = _mm_loadu_ps(b.as_ptr().add(i));
-        let diff = _mm_sub_ps(va, vb);
-        let abs_diff = _mm_and_ps(diff, sign_mask);
-        sum = _mm_add_ps(sum, abs_diff);
-        i += 4;
-    }
+unsafe fn manhattan_distance_sse2(a: &[f32], b: &[f32]) -> f32 {
+    unsafe {
+        let len = a.len();
+        let mut sum = _mm_setzero_ps();
+        let mut i = 0;
+
+        // Sign bit mask for abs()
+        let sign_mask = _mm_set1_ps(f32::from_bits(0x7FFF_FFFF));
+
+        // Process 4 floats at a time
+        while i + 4 <= len {
+            let va = _mm_loadu_ps(a.as_ptr().add(i));
+            let vb = _mm_loadu_ps(b.as_ptr().add(i));
+            let diff = _mm_sub_ps(va, vb);
+            let abs_diff = _mm_and_ps(diff, sign_mask);
+            sum = _mm_add_ps(sum, abs_diff);
+            i += 4;
+        }
 
-    // Horizontal sum
-    // _MM_SHUFFLE(2, 3, 0, 1) = 0b10110001 = 177
-    let sum_shuf = _mm_shuffle_ps(sum, sum, 0b10110001);
-    let sums = _mm_add_ps(sum, sum_shuf);
-    let sums_shuf = _mm_movehl_ps(sums, sums);
-    let result_ss = _mm_add_ss(sums, sums_shuf);
-    let mut result = _mm_cvtss_f32(result_ss);
+        // Horizontal sum
+        // _MM_SHUFFLE(2, 3, 0, 1) = 0b10110001 = 177
+        let sum_shuf = _mm_shuffle_ps(sum, sum, 0b10110001);
+        let sums = _mm_add_ps(sum, sum_shuf);
+        let sums_shuf = _mm_movehl_ps(sums, sums);
+        let result_ss = _mm_add_ss(sums, sums_shuf);
+        let mut result = _mm_cvtss_f32(result_ss);
+
+        // Handle remaining elements
+        while i < len {
+            result += (a[i] - b[i]).abs();
+            i += 1;
+        }
 
-    // Handle remaining elements
-    while i < len {
-        result += (a[i] - b[i]).abs();
-        i += 1;
+        result
     }
-
-    result
-}}
+}
 
 /// ARM NEON implementation for Manhattan distance (processes 4 floats at once)
 #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
diff --git a/src/sparse_native.rs b/src/sparse_native.rs
index 1d03c4f..73d762c 100644
--- a/src/sparse_native.rs
+++ b/src/sparse_native.rs
@@ -38,10 +38,10 @@
 //! )?;
 //! ```
 
-use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 // ============================================================================
 // SPARSE VECTOR
@@ -71,7 +71,8 @@ impl SparseVector {
     /// Create from dense vector (keeping non-zero elements)
     #[inline]
     pub fn from_dense(dense: &[f32], threshold: f32) -> Self {
-        let pairs: Vec<(u32, f32)> = dense.iter()
+        let pairs: Vec<(u32, f32)> = dense
+            .iter()
             .enumerate()
             .filter(|(_, v)| v.abs() > threshold)
             .map(|(i, v)| (i as u32, *v))
@@ -356,7 +357,7 @@ impl HybridSparseIndex {
                 if d.len() != dim {
                     return Err(VecStoreError::DimensionMismatch {
                         expected: dim,
-                        got: d.len()
+                        got: d.len(),
                     });
                 }
             } else {
@@ -414,7 +415,8 @@ impl HybridSparseIndex {
     /// Sparse-only search
     #[inline]
     pub fn sparse_search(&self, query: &SparseVector, top_k: usize) -> Vec<SparseSearchResult> {
-        self.sparse_index.search(query, top_k)
+        self.sparse_index
+            .search(query, top_k)
             .into_iter()
             .filter_map(|(doc_id, score)| {
                 self.idx_to_id.get(&doc_id).map(|id| SparseSearchResult {
@@ -430,7 +432,9 @@ impl HybridSparseIndex {
     /// Dense-only search (brute force)
     #[inline]
     pub fn dense_search(&self, query: &[f32], top_k: usize) -> Vec<SparseSearchResult> {
-        let mut results: Vec<_> = self.dense_vectors.iter()
+        let mut results: Vec<_> = self
+            .dense_vectors
+            .iter()
             .map(|(&doc_id, vec)| {
                 let score = cosine_similarity(query, vec);
                 (doc_id, score)
@@ -440,7 +444,8 @@ impl HybridSparseIndex {
         results.sort_by(|a, b| b.1.total_cmp(&a.1));
         results.truncate(top_k);
 
-        results.into_iter()
+        results
+            .into_iter()
             .filter_map(|(doc_id, score)| {
                 self.idx_to_id.get(&doc_id).map(|id| SparseSearchResult {
                     id: id.clone(),
@@ -460,7 +465,7 @@ impl HybridSparseIndex {
         &self,
         sparse_query: Option<&SparseVector>,
         dense_query: Option<&[f32]>,
-        alpha: f32,  // Weight for dense (0.0 = all sparse, 1.0 = all dense)
+        alpha: f32, // Weight for dense (0.0 = all sparse, 1.0 = all dense)
         top_k: usize,
     ) -> Vec<SparseSearchResult> {
         let mut scores: HashMap<u32, (Option<f32>, Option<f32>)> = HashMap::new();
@@ -481,16 +486,25 @@ impl HybridSparseIndex {
         }
 
         // Normalize and combine
-        let max_sparse = scores.values()
+        let max_sparse = scores
+            .values()
             .filter_map(|(s, _)| *s)
             .fold(0.0f32, |a, b| a.max(b));
-        let max_dense = scores.values()
+        let max_dense = scores
+            .values()
             .filter_map(|(_, d)| *d)
             .fold(0.0f32, |a, b| a.max(b));
 
-        let mut results: Vec<_> = scores.into_iter()
+        let mut results: Vec<_> = scores
+            .into_iter()
             .map(|(doc_id, (sparse, dense))| {
-                let norm_sparse = sparse.map(|s| if max_sparse > 0.0 { s / max_sparse } else { 0.0 });
+                let norm_sparse = sparse.map(|s| {
+                    if max_sparse > 0.0 {
+                        s / max_sparse
+                    } else {
+                        0.0
+                    }
+                });
                 let norm_dense = dense.map(|d| if max_dense > 0.0 { d / max_dense } else { 0.0 });
 
                 let final_score = match (norm_sparse, norm_dense) {
@@ -507,7 +521,8 @@ impl HybridSparseIndex {
         results.sort_by(|a, b| b.1.total_cmp(&a.1));
         results.truncate(top_k);
 
-        results.into_iter()
+        results
+            .into_iter()
             .filter_map(|(doc_id, score, sparse, dense)| {
                 self.idx_to_id.get(&doc_id).map(|id| SparseSearchResult {
                     id: id.clone(),
@@ -588,15 +603,14 @@ impl SpladeEncoder {
     pub fn new(config: SpladeConfig) -> Result<Self> {
         // Initialize stopwords
         let stopwords: std::collections::HashSet<String> = [
-            "the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for",
-            "of", "with", "by", "from", "as", "is", "was", "are", "were", "been",
-            "be", "have", "has", "had", "do", "does", "did", "will", "would", "could",
-            "should", "may", "might", "must", "shall", "can", "need", "dare", "ought",
-            "used", "it", "its", "this", "that", "these", "those", "i", "you", "he",
-            "she", "we", "they", "what", "which", "who", "whom", "whose", "where",
-            "when", "why", "how", "all", "each", "every", "both", "few", "more",
-            "most", "other", "some", "such", "no", "nor", "not", "only", "own",
-            "same", "so", "than", "too", "very", "just", "also", "now", "here",
+            "the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for", "of", "with",
+            "by", "from", "as", "is", "was", "are", "were", "been", "be", "have", "has", "had",
+            "do", "does", "did", "will", "would", "could", "should", "may", "might", "must",
+            "shall", "can", "need", "dare", "ought", "used", "it", "its", "this", "that", "these",
+            "those", "i", "you", "he", "she", "we", "they", "what", "which", "who", "whom",
+            "whose", "where", "when", "why", "how", "all", "each", "every", "both", "few", "more",
+            "most", "other", "some", "such", "no", "nor", "not", "only", "own", "same", "so",
+            "than", "too", "very", "just", "also", "now", "here",
         ]
         .iter()
         .map(|s| s.to_string())
@@ -727,8 +741,12 @@ mod tests {
         let sparse2 = SparseVector::new(vec![(2, 0.7), (3, 0.6)]);
         let dense2 = vec![0.5, 0.6, 0.7, 0.8];
 
-        index.upsert("doc1", Some(sparse1), Some(dense1), None).unwrap();
-        index.upsert("doc2", Some(sparse2), Some(dense2), None).unwrap();
+        index
+            .upsert("doc1", Some(sparse1), Some(dense1), None)
+            .unwrap();
+        index
+            .upsert("doc2", Some(sparse2), Some(dense2), None)
+            .unwrap();
 
         // Hybrid search
         let query_sparse = SparseVector::new(vec![(1, 1.0), (2, 0.5)]);
@@ -737,7 +755,7 @@ mod tests {
         let results = index.hybrid_search(
             Some(&query_sparse),
             Some(&query_dense),
-            0.5,  // Equal weight
+            0.5, // Equal weight
             10,
         );
 
diff --git a/src/splade.rs b/src/splade.rs
index 7fb90dd..94eaa84 100644
--- a/src/splade.rs
+++ b/src/splade.rs
@@ -278,15 +278,14 @@ impl SpladeEncoder {
     pub fn new(config: SpladeConfig) -> Result<Self> {
         // Initialize stopwords set for filtering common words
         let stopwords: std::collections::HashSet<String> = [
-            "the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for",
-            "of", "with", "by", "from", "as", "is", "was", "are", "were", "been",
-            "be", "have", "has", "had", "do", "does", "did", "will", "would", "could",
-            "should", "may", "might", "must", "shall", "can", "need", "dare", "ought",
-            "used", "it", "its", "this", "that", "these", "those", "i", "you", "he",
-            "she", "we", "they", "what", "which", "who", "whom", "whose", "where",
-            "when", "why", "how", "all", "each", "every", "both", "few", "more",
-            "most", "other", "some", "such", "no", "nor", "not", "only", "own",
-            "same", "so", "than", "too", "very", "just", "also", "now", "here",
+            "the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for", "of", "with",
+            "by", "from", "as", "is", "was", "are", "were", "been", "be", "have", "has", "had",
+            "do", "does", "did", "will", "would", "could", "should", "may", "might", "must",
+            "shall", "can", "need", "dare", "ought", "used", "it", "its", "this", "that", "these",
+            "those", "i", "you", "he", "she", "we", "they", "what", "which", "who", "whom",
+            "whose", "where", "when", "why", "how", "all", "each", "every", "both", "few", "more",
+            "most", "other", "some", "such", "no", "nor", "not", "only", "own", "same", "so",
+            "than", "too", "very", "just", "also", "now", "here",
         ]
         .iter()
         .map(|s| s.to_string())
diff --git a/src/sql.rs b/src/sql.rs
index 998d430..3dadd5f 100644
--- a/src/sql.rs
+++ b/src/sql.rs
@@ -38,10 +38,10 @@
 //! - `<=>` : Cosine distance
 //! - `<#>` : Inner product (negative dot product)
 
-use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 /// SQL parser and executor for vector operations
 pub struct VectorSQL {
@@ -75,7 +75,7 @@ pub enum DataType {
     Integer,
     Float,
     Boolean,
-    Vector(usize),  // Vector with dimension
+    Vector(usize), // Vector with dimension
     Json,
     Timestamp,
 }
@@ -86,7 +86,7 @@ impl DataType {
         let s = s.trim().to_uppercase();
 
         if s.starts_with("VECTOR(") && s.ends_with(')') {
-            let dim_str = &s[7..s.len()-1];
+            let dim_str = &s[7..s.len() - 1];
             let dim: usize = dim_str.parse().map_err(|_| {
                 VecStoreError::InvalidInput(format!("Invalid vector dimension: {}", dim_str))
             })?;
@@ -100,7 +100,10 @@ impl DataType {
             "BOOL" | "BOOLEAN" => Ok(DataType::Boolean),
             "JSON" | "JSONB" => Ok(DataType::Json),
             "TIMESTAMP" | "DATETIME" => Ok(DataType::Timestamp),
-            _ => Err(VecStoreError::InvalidInput(format!("Unknown data type: {}", s))),
+            _ => Err(VecStoreError::InvalidInput(format!(
+                "Unknown data type: {}",
+                s
+            ))),
         }
     }
 }
@@ -182,7 +185,7 @@ pub struct SelectStmt {
 /// SELECT column expression
 #[derive(Debug, Clone)]
 pub enum SelectColumn {
-    All,  // *
+    All, // *
     Column(String),
     Distance {
         column: String,
@@ -200,8 +203,8 @@ pub enum SelectColumn {
 /// Distance metrics
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum DistanceMetric {
-    L2,       // <->
-    Cosine,   // <=>
+    L2,         // <->
+    Cosine,     // <=>
     DotProduct, // <#>
 }
 
@@ -249,7 +252,10 @@ pub struct OrderByClause {
 /// ORDER BY column
 #[derive(Debug, Clone)]
 pub enum OrderByColumn {
-    Column { name: String, descending: bool },
+    Column {
+        name: String,
+        descending: bool,
+    },
     VectorDistance {
         column: String,
         target: Vec<f32>,
@@ -357,7 +363,10 @@ impl VectorSQL {
         } else if upper.starts_with("CREATE INDEX") {
             self.parse_create_index(sql)
         } else {
-            Err(VecStoreError::InvalidInput(format!("Unknown SQL statement: {}", sql)))
+            Err(VecStoreError::InvalidInput(format!(
+                "Unknown SQL statement: {}",
+                sql
+            )))
         }
     }
 
@@ -370,9 +379,9 @@ impl VectorSQL {
         let if_not_exists = upper.contains("IF NOT EXISTS");
 
         // Find table name and columns
-        let paren_start = sql.find('(').ok_or_else(|| {
-            VecStoreError::InvalidInput("Missing column definitions".to_string())
-        })?;
+        let paren_start = sql
+            .find('(')
+            .ok_or_else(|| VecStoreError::InvalidInput("Missing column definitions".to_string()))?;
         let paren_end = sql.rfind(')').ok_or_else(|| {
             VecStoreError::InvalidInput("Missing closing parenthesis".to_string())
         })?;
@@ -380,9 +389,10 @@ impl VectorSQL {
         // Extract table name
         let before_paren = &sql[..paren_start].trim();
         let parts: Vec<&str> = before_paren.split_whitespace().collect();
-        let table_name = parts.last().ok_or_else(|| {
-            VecStoreError::InvalidInput("Missing table name".to_string())
-        })?.to_string();
+        let table_name = parts
+            .last()
+            .ok_or_else(|| VecStoreError::InvalidInput("Missing table name".to_string()))?
+            .to_string();
 
         // Parse columns
         let columns_str = &sql[paren_start + 1..paren_end];
@@ -441,9 +451,11 @@ impl VectorSQL {
     /// Parse DROP TABLE
     fn parse_drop_table(&self, sql: &str) -> Result<Statement> {
         let parts: Vec<&str> = sql.split_whitespace().collect();
-        let table_name = parts.last().ok_or_else(|| {
-            VecStoreError::InvalidInput("Missing table name".to_string())
-        })?.trim_end_matches(';').to_string();
+        let table_name = parts
+            .last()
+            .ok_or_else(|| VecStoreError::InvalidInput("Missing table name".to_string()))?
+            .trim_end_matches(';')
+            .to_string();
 
         Ok(Statement::DropTable(table_name))
     }
@@ -454,9 +466,9 @@ impl VectorSQL {
         let upper = sql.to_uppercase();
 
         // Find table name
-        let into_pos = upper.find("INTO").ok_or_else(|| {
-            VecStoreError::InvalidInput("Missing INTO".to_string())
-        })?;
+        let into_pos = upper
+            .find("INTO")
+            .ok_or_else(|| VecStoreError::InvalidInput("Missing INTO".to_string()))?;
 
         let after_into = &sql[into_pos + 4..].trim_start();
         let paren_pos = after_into.find('(').unwrap_or(after_into.len());
@@ -475,9 +487,9 @@ impl VectorSQL {
         let upper = sql.to_uppercase();
 
         // Find FROM
-        let from_pos = upper.find(" FROM ").ok_or_else(|| {
-            VecStoreError::InvalidInput("Missing FROM clause".to_string())
-        })?;
+        let from_pos = upper
+            .find(" FROM ")
+            .ok_or_else(|| VecStoreError::InvalidInput("Missing FROM clause".to_string()))?;
 
         // Parse columns (between SELECT and FROM)
         let select_pos = upper.find("SELECT").unwrap();
@@ -486,21 +498,24 @@ impl VectorSQL {
         let columns = if columns_str.trim() == "*" {
             vec![SelectColumn::All]
         } else {
-            columns_str.split(',')
+            columns_str
+                .split(',')
                 .map(|c| SelectColumn::Column(c.trim().to_string()))
                 .collect()
         };
 
         // Find table name (after FROM)
         let after_from = &sql[from_pos + 6..];
-        let table_end = after_from.find(|c: char| c.is_whitespace() || c == ';')
+        let table_end = after_from
+            .find(|c: char| c.is_whitespace() || c == ';')
             .unwrap_or(after_from.len());
         let from = after_from[..table_end].trim().to_string();
 
         // Parse LIMIT
         let limit = if let Some(limit_pos) = upper.find(" LIMIT ") {
             let after_limit = &sql[limit_pos + 7..];
-            let end = after_limit.find(|c: char| !c.is_numeric())
+            let end = after_limit
+                .find(|c: char| !c.is_numeric())
                 .unwrap_or(after_limit.len());
             after_limit[..end].trim().parse().ok()
         } else {
@@ -511,9 +526,14 @@ impl VectorSQL {
         let order_by = if let Some(order_pos) = upper.find(" ORDER BY ") {
             let after_order = &sql[order_pos + 10..];
             // Check for vector distance operators
-            if after_order.contains("<->") || after_order.contains("<=>") || after_order.contains("<#>") {
+            if after_order.contains("<->")
+                || after_order.contains("<=>")
+                || after_order.contains("<#>")
+            {
                 // Parse vector order by
-                Some(OrderByClause { columns: Vec::new() })
+                Some(OrderByClause {
+                    columns: Vec::new(),
+                })
             } else {
                 None
             }
@@ -556,7 +576,8 @@ impl VectorSQL {
         let using_pos = upper.find(" USING ");
         let index_type = if let Some(pos) = using_pos {
             let after_using = &upper[pos + 7..];
-            let end = after_using.find(|c: char| c.is_whitespace() || c == '(')
+            let end = after_using
+                .find(|c: char| c.is_whitespace() || c == '(')
                 .unwrap_or(after_using.len());
             match &after_using[..end] {
                 "HNSW" => IndexType::Hnsw,
@@ -590,23 +611,25 @@ impl VectorSQL {
                 });
             }
             return Err(VecStoreError::InvalidInput(format!(
-                "Table '{}' already exists", stmt.table_name
+                "Table '{}' already exists",
+                stmt.table_name
             )));
         }
 
         // Find vector column
-        let vector_column = stmt.columns.iter()
+        let vector_column = stmt
+            .columns
+            .iter()
             .find(|c| matches!(c.data_type, DataType::Vector(_)))
             .map(|c| c.name.clone());
 
-        let dimension = stmt.columns.iter()
-            .find_map(|c| {
-                if let DataType::Vector(dim) = c.data_type {
-                    Some(dim)
-                } else {
-                    None
-                }
-            });
+        let dimension = stmt.columns.iter().find_map(|c| {
+            if let DataType::Vector(dim) = c.data_type {
+                Some(dim)
+            } else {
+                None
+            }
+        });
 
         let primary_key = stmt.columns.first().map(|c| c.name.clone());
 
@@ -656,9 +679,10 @@ impl VectorSQL {
 
     /// Execute SELECT
     fn execute_select(&self, stmt: SelectStmt) -> Result<QueryResult> {
-        let table_data = self.data.get(&stmt.from).ok_or_else(|| {
-            VecStoreError::NotFound(format!("Table '{}' not found", stmt.from))
-        })?;
+        let table_data = self
+            .data
+            .get(&stmt.from)
+            .ok_or_else(|| VecStoreError::NotFound(format!("Table '{}' not found", stmt.from)))?;
 
         let column_names: Vec<String> = match &stmt.columns[..] {
             [SelectColumn::All] => {
@@ -667,26 +691,29 @@ impl VectorSQL {
                 } else {
                     Vec::new()
                 }
-            }
-            cols => cols.iter().map(|c| match c {
-                SelectColumn::Column(name) => name.clone(),
-                SelectColumn::Distance { alias, .. } => {
-                    alias.clone().unwrap_or_else(|| "distance".to_string())
-                }
-                SelectColumn::Function { alias, name, .. } => {
-                    alias.clone().unwrap_or_else(|| name.clone())
-                }
-                SelectColumn::All => "*".to_string(),
-            }).collect(),
+            },
+            cols => cols
+                .iter()
+                .map(|c| match c {
+                    SelectColumn::Column(name) => name.clone(),
+                    SelectColumn::Distance { alias, .. } => {
+                        alias.clone().unwrap_or_else(|| "distance".to_string())
+                    },
+                    SelectColumn::Function { alias, name, .. } => {
+                        alias.clone().unwrap_or_else(|| name.clone())
+                    },
+                    SelectColumn::All => "*".to_string(),
+                })
+                .collect(),
         };
 
-        let rows: Vec<ResultRow> = table_data.iter()
+        let rows: Vec<ResultRow> = table_data
+            .iter()
             .take(stmt.limit.unwrap_or(100))
             .map(|row| {
-                let values: Vec<Value> = column_names.iter()
-                    .map(|col| {
-                        row.metadata.get(col).cloned().unwrap_or(Value::Null)
-                    })
+                let values: Vec<Value> = column_names
+                    .iter()
+                    .map(|col| row.metadata.get(col).cloned().unwrap_or(Value::Null))
                     .collect();
                 ResultRow { values }
             })
@@ -824,7 +851,8 @@ impl VectorQueryBuilder {
             };
             sql.push_str(&format!(
                 " ORDER BY {} {} '[{:?}]'",
-                col, operator,
+                col,
+                operator,
                 vec.iter().take(3).collect::<Vec<_>>()
             ));
         }
@@ -845,13 +873,15 @@ mod tests {
     fn test_create_table() {
         let mut sql = VectorSQL::new();
 
-        let result = sql.execute(
-            "CREATE TABLE documents (
+        let result = sql
+            .execute(
+                "CREATE TABLE documents (
                 id TEXT PRIMARY KEY,
                 embedding VECTOR(384),
                 content TEXT
-            )"
-        ).unwrap();
+            )",
+            )
+            .unwrap();
 
         assert_eq!(result.affected_rows, 0);
         assert!(sql.tables.contains_key("documents"));
@@ -860,7 +890,10 @@ mod tests {
     #[test]
     fn test_data_type_parse() {
         assert_eq!(DataType::parse("TEXT").unwrap(), DataType::Text);
-        assert_eq!(DataType::parse("VECTOR(384)").unwrap(), DataType::Vector(384));
+        assert_eq!(
+            DataType::parse("VECTOR(384)").unwrap(),
+            DataType::Vector(384)
+        );
         assert_eq!(DataType::parse("INTEGER").unwrap(), DataType::Integer);
     }
 
diff --git a/src/store/advanced_filters.rs b/src/store/advanced_filters.rs
index 42b49e7..24d017a 100644
--- a/src/store/advanced_filters.rs
+++ b/src/store/advanced_filters.rs
@@ -56,7 +56,7 @@ impl GeoFilter {
                     && point.lat <= ne.lat
                     && point.lon >= sw.lon
                     && point.lon <= ne.lon
-            }
+            },
         }
     }
 
@@ -104,13 +104,15 @@ impl DateRangeFilter {
     /// Check if a timestamp matches this filter
     pub fn matches(&self, timestamp: i64) -> bool {
         if let Some(start) = self.start
-            && timestamp < start {
-                return false;
-            }
+            && timestamp < start
+        {
+            return false;
+        }
         if let Some(end) = self.end
-            && timestamp > end {
-                return false;
-            }
+            && timestamp > end
+        {
+            return false;
+        }
         true
     }
 
@@ -133,13 +135,15 @@ impl NumericRangeFilter {
 
     pub fn matches(&self, value: f64) -> bool {
         if let Some(min) = self.min
-            && value < min {
-                return false;
-            }
+            && value < min
+        {
+            return false;
+        }
         if let Some(max) = self.max
-            && value > max {
-                return false;
-            }
+            && value > max
+        {
+            return false;
+        }
         true
     }
 }
@@ -179,15 +183,17 @@ impl ArrayFilter {
             ArrayFilter::Length { min, max } => {
                 let len = arr.len();
                 if let Some(min_len) = min
-                    && len < *min_len {
-                        return false;
-                    }
+                    && len < *min_len
+                {
+                    return false;
+                }
                 if let Some(max_len) = max
-                    && len > *max_len {
-                        return false;
-                    }
+                    && len > *max_len
+                {
+                    return false;
+                }
                 true
-            }
+            },
         }
     }
 }
@@ -219,7 +225,7 @@ impl AdvancedFilter {
                 } else {
                     false
                 }
-            }
+            },
 
             AdvancedFilter::DateRange { field, filter } => {
                 if let Some(timestamp) = DateRangeFilter::extract_timestamp(metadata, field) {
@@ -227,7 +233,7 @@ impl AdvancedFilter {
                 } else {
                     false
                 }
-            }
+            },
 
             AdvancedFilter::NumericRange { field, filter } => {
                 if let Some(value) = metadata.fields.get(field).and_then(|v| v.as_f64()) {
@@ -235,7 +241,7 @@ impl AdvancedFilter {
                 } else {
                     false
                 }
-            }
+            },
 
             AdvancedFilter::Array { field, filter } => {
                 if let Some(array) = metadata.fields.get(field) {
@@ -243,7 +249,7 @@ impl AdvancedFilter {
                 } else {
                     false
                 }
-            }
+            },
         }
     }
 }
diff --git a/src/store/disk_hnsw.rs b/src/store/disk_hnsw.rs
index 7038954..b018ba7 100644
--- a/src/store/disk_hnsw.rs
+++ b/src/store/disk_hnsw.rs
@@ -28,10 +28,10 @@
 //! - Background compaction
 //! - Cache-aware graph traversal
 
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result, anyhow};
 use memmap2::{Mmap, MmapOptions};
-use std::collections::{BinaryHeap, HashMap, HashSet};
 use std::cmp::Ordering;
+use std::collections::{BinaryHeap, HashMap, HashSet};
 use std::fs::OpenOptions;
 use std::io::{Read, Seek, SeekFrom, Write};
 use std::path::{Path, PathBuf};
@@ -399,9 +399,8 @@ impl DiskHNSW {
         // Read current header to get data_length (position after last node)
         let mut header_buf = vec![0u8; FileHeader::SIZE];
         file.read_exact(&mut header_buf)?;
-        let current_data_length = unsafe {
-            (*(header_buf.as_ptr() as *const FileHeader)).data_length
-        };
+        let current_data_length =
+            unsafe { (*(header_buf.as_ptr() as *const FileHeader)).data_length };
 
         // Seek to end of actual data (not end of file which may have padding)
         let file_len = file.metadata()?.len();
@@ -451,7 +450,8 @@ impl DiskHNSW {
         drop(file);
 
         // Update offset tables
-        self.node_layer_offsets.insert((node.id, node.layer), offset);
+        self.node_layer_offsets
+            .insert((node.id, node.layer), offset);
         if node.layer == 0 {
             self.node_offsets.insert(node.id, offset);
         }
@@ -529,7 +529,8 @@ impl DiskHNSW {
             .ok_or_else(|| anyhow!("Index not mapped"))?;
 
         // Try to acquire read lock without blocking
-        let mmap = mmap_arc.try_read()
+        let mmap = mmap_arc
+            .try_read()
             .map_err(|_| anyhow!("Lock held - use get_node_async() for async access"))?;
 
         let offset = offset as usize;
@@ -767,8 +768,8 @@ impl DiskVectorStorage {
         file.write_all(b"VECS")?;
         file.write_all(&1u32.to_le_bytes())?;
         file.write_all(&(dimension as u64).to_le_bytes())?;
-        file.write_all(&0u64.to_le_bytes())?;  // Initial count
-        file.write_all(&[0u8; 8])?;  // Reserved
+        file.write_all(&0u64.to_le_bytes())?; // Initial count
+        file.write_all(&[0u8; 8])?; // Reserved
 
         // Allocate initial space (10K vectors worth)
         let initial_size = Self::HEADER_SIZE + (10_000 * dimension * 4);
@@ -776,9 +777,7 @@ impl DiskVectorStorage {
         file.flush()?;
         drop(file);
 
-        let file = OpenOptions::new()
-            .read(true)
-            .open(&file_path)?;
+        let file = OpenOptions::new().read(true).open(&file_path)?;
         let mmap = unsafe { MmapOptions::new().map(&file)? };
 
         Ok(Self {
@@ -926,7 +925,11 @@ pub struct DiskHNSWIndex {
 
 impl DiskHNSWIndex {
     /// Create a new disk-backed HNSW index
-    pub fn create(base_path: impl AsRef<Path>, dimension: usize, config: DiskHNSWConfig) -> Result<Self> {
+    pub fn create(
+        base_path: impl AsRef<Path>,
+        dimension: usize,
+        config: DiskHNSWConfig,
+    ) -> Result<Self> {
         let base = base_path.as_ref();
         std::fs::create_dir_all(base)?;
 
@@ -1007,7 +1010,9 @@ impl DiskHNSWIndex {
         }
 
         // Get entry point
-        let (ep_id, ep_layer) = self.graph.get_entry_point()
+        let (ep_id, ep_layer) = self
+            .graph
+            .get_entry_point()
             .ok_or_else(|| anyhow!("No entry point found"))?;
 
         let mut current_ep = ep_id;
@@ -1096,7 +1101,7 @@ impl DiskHNSWIndex {
             None => {
                 // Fallback to brute force if no entry point
                 return self.search_brute_force(query, k);
-            }
+            },
         };
 
         let mut current_ep = ep_id;
@@ -1115,9 +1120,7 @@ impl DiskHNSWIndex {
         let results: Vec<(String, f32)> = candidates
             .into_iter()
             .take(k)
-            .filter_map(|(idx, dist)| {
-                self.index_to_id.get(&idx).map(|id| (id.clone(), dist))
-            })
+            .filter_map(|(idx, dist)| self.index_to_id.get(&idx).map(|id| (id.clone(), dist)))
             .collect();
 
         // If we didn't find enough results via HNSW, fall back to brute force
@@ -1149,11 +1152,12 @@ impl DiskHNSWIndex {
             let mut found_closer = false;
             for neighbor in neighbors {
                 if let Ok(dist) = self.get_distance(query, neighbor)
-                    && dist < current_dist {
-                        current = neighbor;
-                        current_dist = dist;
-                        found_closer = true;
-                    }
+                    && dist < current_dist
+                {
+                    current = neighbor;
+                    current_dist = dist;
+                    found_closer = true;
+                }
             }
 
             if !found_closer {
@@ -1166,24 +1170,37 @@ impl DiskHNSWIndex {
 
     /// Beam search within a layer - find ef closest nodes
     #[cfg(not(feature = "async"))]
-    fn search_layer_beam(&self, query: &[f32], entry: u64, layer: u8, ef: usize) -> Result<Vec<(u64, f32)>> {
+    fn search_layer_beam(
+        &self,
+        query: &[f32],
+        entry: u64,
+        layer: u8,
+        ef: usize,
+    ) -> Result<Vec<(u64, f32)>> {
         let mut visited = HashSet::new();
         let mut candidates: BinaryHeap<Candidate> = BinaryHeap::new();
         let mut results: BinaryHeap<MinCandidate> = BinaryHeap::new();
 
         // Start with entry point
         let entry_dist = self.get_distance(query, entry)?;
-        candidates.push(Candidate { id: entry, distance: entry_dist });
-        results.push(MinCandidate { id: entry, distance: entry_dist });
+        candidates.push(Candidate {
+            id: entry,
+            distance: entry_dist,
+        });
+        results.push(MinCandidate {
+            id: entry,
+            distance: entry_dist,
+        });
         visited.insert(entry);
 
         while let Some(current) = candidates.pop() {
             // Stop if current is further than the worst result
             if results.len() >= ef
                 && let Some(worst) = results.peek()
-                    && current.distance > worst.distance {
-                        break;
-                    }
+                && current.distance > worst.distance
+            {
+                break;
+            }
 
             // Get neighbors
             let neighbors = match self.graph.get_neighbors_at_layer(current.id, layer) {
@@ -1208,8 +1225,14 @@ impl DiskHNSWIndex {
                     };
 
                     if should_add {
-                        candidates.push(Candidate { id: neighbor, distance: dist });
-                        results.push(MinCandidate { id: neighbor, distance: dist });
+                        candidates.push(Candidate {
+                            id: neighbor,
+                            distance: dist,
+                        });
+                        results.push(MinCandidate {
+                            id: neighbor,
+                            distance: dist,
+                        });
 
                         // Trim results if too large
                         while results.len() > ef {
@@ -1221,10 +1244,8 @@ impl DiskHNSWIndex {
         }
 
         // Convert to sorted vec
-        let mut result_vec: Vec<(u64, f32)> = results
-            .into_iter()
-            .map(|c| (c.id, c.distance))
-            .collect();
+        let mut result_vec: Vec<(u64, f32)> =
+            results.into_iter().map(|c| (c.id, c.distance)).collect();
         result_vec.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap());
 
         Ok(result_vec)
@@ -1246,9 +1267,7 @@ impl DiskHNSWIndex {
 
         let results: Vec<(String, f32)> = distances
             .into_iter()
-            .filter_map(|(idx, dist)| {
-                self.index_to_id.get(&idx).map(|id| (id.clone(), dist))
-            })
+            .filter_map(|(idx, dist)| self.index_to_id.get(&idx).map(|id| (id.clone(), dist)))
             .collect();
 
         Ok(results)
@@ -1481,9 +1500,15 @@ mod tests {
         let mut index = DiskHNSWIndex::create(&base_path, 4, config).unwrap();
 
         // Insert vectors
-        index.insert("doc1".to_string(), vec![1.0, 0.0, 0.0, 0.0]).unwrap();
-        index.insert("doc2".to_string(), vec![0.0, 1.0, 0.0, 0.0]).unwrap();
-        index.insert("doc3".to_string(), vec![0.0, 0.0, 1.0, 0.0]).unwrap();
+        index
+            .insert("doc1".to_string(), vec![1.0, 0.0, 0.0, 0.0])
+            .unwrap();
+        index
+            .insert("doc2".to_string(), vec![0.0, 1.0, 0.0, 0.0])
+            .unwrap();
+        index
+            .insert("doc3".to_string(), vec![0.0, 0.0, 1.0, 0.0])
+            .unwrap();
 
         let stats = index.stats();
         assert_eq!(stats.vector_count, 3);
diff --git a/src/store/filter_parser.rs b/src/store/filter_parser.rs
index 0f172b0..2a2e43e 100644
--- a/src/store/filter_parser.rs
+++ b/src/store/filter_parser.rs
@@ -123,7 +123,7 @@ impl Lexer {
                         _ => {
                             s.push('\\');
                             s.push(escaped);
-                        }
+                        },
                     }
                 }
             } else {
@@ -178,27 +178,27 @@ impl Lexer {
             Some('(') => {
                 self.advance();
                 Ok(Token::LParen)
-            }
+            },
             Some(')') => {
                 self.advance();
                 Ok(Token::RParen)
-            }
+            },
             Some('[') => {
                 self.advance();
                 Ok(Token::LBracket)
-            }
+            },
             Some(']') => {
                 self.advance();
                 Ok(Token::RBracket)
-            }
+            },
             Some(',') => {
                 self.advance();
                 Ok(Token::Comma)
-            }
+            },
             Some('=') => {
                 self.advance();
                 Ok(Token::Eq)
-            }
+            },
             Some('!') => {
                 self.advance();
                 if self.peek() == Some('=') {
@@ -207,7 +207,7 @@ impl Lexer {
                 } else {
                     Err(ParseError::UnexpectedToken("!".to_string()))
                 }
-            }
+            },
             Some('>') => {
                 self.advance();
                 if self.peek() == Some('=') {
@@ -216,7 +216,7 @@ impl Lexer {
                 } else {
                     Ok(Token::Gt)
                 }
-            }
+            },
             Some('<') => {
                 self.advance();
                 if self.peek() == Some('=') {
@@ -225,16 +225,16 @@ impl Lexer {
                 } else {
                     Ok(Token::Lt)
                 }
-            }
+            },
             Some('\'') | Some('"') => {
                 let quote = self.advance().unwrap();
                 let s = self.read_string(quote)?;
                 Ok(Token::String(s))
-            }
+            },
             Some(ch) if ch.is_numeric() || ch == '-' => {
                 let n = self.read_number()?;
                 Ok(Token::Number(n))
-            }
+            },
             Some(ch) if ch.is_alphabetic() || ch == '_' => {
                 let ident = self.read_ident_or_keyword();
                 let upper = ident.to_uppercase();
@@ -266,7 +266,7 @@ impl Lexer {
                     "STARTSWITH" => Ok(Token::StartsWith), // Major Issue #13 fix
                     _ => Ok(Token::Ident(ident)),
                 }
-            }
+            },
             Some(ch) => Err(ParseError::UnexpectedToken(ch.to_string())),
         }
     }
@@ -367,13 +367,13 @@ impl Parser {
                 let name = name.clone();
                 self.advance()?;
                 name
-            }
+            },
             _ => {
                 return Err(ParseError::Expected {
                     expected: "field name".to_string(),
                     got: format!("{:?}", self.current),
-                })
-            }
+                });
+            },
         };
 
         let op = match &self.current {
@@ -392,8 +392,8 @@ impl Parser {
                     expected: "operator (=, !=, >, >=, <, <=, CONTAINS, IN, STARTSWITH)"
                         .to_string(),
                     got: format!("{:?}", self.current),
-                })
-            }
+                });
+            },
         };
         self.advance()?;
 
@@ -422,7 +422,7 @@ impl Parser {
                         let s = s.clone();
                         self.advance()?;
                         serde_json::json!(s)
-                    }
+                    },
                     Token::Number(n) => {
                         let n = *n;
                         self.advance()?;
@@ -431,7 +431,7 @@ impl Parser {
                         } else {
                             serde_json::json!(n)
                         }
-                    }
+                    },
                     Token::Ident(s) => {
                         let s = s.clone();
                         self.advance()?;
@@ -441,13 +441,13 @@ impl Parser {
                             "null" => serde_json::json!(null),
                             _ => serde_json::json!(s),
                         }
-                    }
+                    },
                     _ => {
                         return Err(ParseError::Expected {
                             expected: "array element (string, number, or identifier)".to_string(),
                             got: format!("{:?}", self.current),
-                        })
-                    }
+                        });
+                    },
                 };
                 elements.push(elem);
 
@@ -456,17 +456,17 @@ impl Parser {
                     Token::Comma => {
                         self.advance()?;
                         // Continue to next element
-                    }
+                    },
                     Token::RBracket => {
                         self.advance()?;
                         break;
-                    }
+                    },
                     _ => {
                         return Err(ParseError::Expected {
                             expected: ", or ]".to_string(),
                             got: format!("{:?}", self.current),
-                        })
-                    }
+                        });
+                    },
                 }
             }
 
@@ -478,7 +478,7 @@ impl Parser {
                     let s = s.clone();
                     self.advance()?;
                     serde_json::json!(s)
-                }
+                },
                 Token::Number(n) => {
                     let n = *n;
                     self.advance()?;
@@ -488,7 +488,7 @@ impl Parser {
                     } else {
                         serde_json::json!(n)
                     }
-                }
+                },
                 Token::Ident(s) => {
                     let s = s.clone();
                     self.advance()?;
@@ -499,13 +499,13 @@ impl Parser {
                         "null" => serde_json::json!(null),
                         _ => serde_json::json!(s),
                     }
-                }
+                },
                 _ => {
                     return Err(ParseError::Expected {
                         expected: "value (string, number, or identifier)".to_string(),
                         got: format!("{:?}", self.current),
-                    })
-                }
+                    });
+                },
             }
         };
 
@@ -539,7 +539,7 @@ mod tests {
                 assert_eq!(field, "name");
                 assert_eq!(op, FilterOp::Eq);
                 assert_eq!(value, serde_json::json!("Alice"));
-            }
+            },
             _ => panic!("Expected Cmp"),
         }
     }
@@ -552,7 +552,7 @@ mod tests {
                 assert_eq!(field, "age");
                 assert_eq!(op, FilterOp::Gt);
                 assert_eq!(value, serde_json::json!(18));
-            }
+            },
             _ => panic!("Expected Cmp"),
         }
     }
@@ -563,7 +563,7 @@ mod tests {
         match filter {
             FilterExpr::And(exprs) => {
                 assert_eq!(exprs.len(), 2);
-            }
+            },
             _ => panic!("Expected And"),
         }
     }
@@ -574,7 +574,7 @@ mod tests {
         match filter {
             FilterExpr::Or(exprs) => {
                 assert_eq!(exprs.len(), 2);
-            }
+            },
             _ => panic!("Expected Or"),
         }
     }
@@ -583,7 +583,7 @@ mod tests {
     fn test_not() {
         let filter = parse_filter("NOT archived = true").unwrap();
         match filter {
-            FilterExpr::Not(_) => {}
+            FilterExpr::Not(_) => {},
             _ => panic!("Expected Not"),
         }
     }
@@ -592,7 +592,7 @@ mod tests {
     fn test_parentheses() {
         let filter = parse_filter("(age > 18 AND role = 'admin') OR vip = true").unwrap();
         match filter {
-            FilterExpr::Or(_) => {}
+            FilterExpr::Or(_) => {},
             _ => panic!("Expected Or"),
         }
     }
@@ -603,7 +603,7 @@ mod tests {
         match filter {
             FilterExpr::Cmp { op, .. } => {
                 assert_eq!(op, FilterOp::Contains);
-            }
+            },
             _ => panic!("Expected Cmp with Contains"),
         }
     }
@@ -617,7 +617,7 @@ mod tests {
 
         // Should parse successfully
         match filter {
-            FilterExpr::And(_) => {}
+            FilterExpr::And(_) => {},
             _ => panic!("Expected And at top level"),
         }
     }
@@ -628,7 +628,7 @@ mod tests {
         match filter {
             FilterExpr::Cmp { value, .. } => {
                 assert_eq!(value, serde_json::json!(true));
-            }
+            },
             _ => panic!("Expected Cmp"),
         }
     }
@@ -639,7 +639,7 @@ mod tests {
         match filter {
             FilterExpr::Cmp { value, .. } => {
                 assert_eq!(value, serde_json::json!("O'Reilly"));
-            }
+            },
             _ => panic!("Expected Cmp"),
         }
     }
@@ -650,7 +650,7 @@ mod tests {
         match filter {
             FilterExpr::Cmp { value, .. } => {
                 assert_eq!(value, serde_json::json!(-10));
-            }
+            },
             _ => panic!("Expected Cmp"),
         }
     }
diff --git a/src/store/filters.rs b/src/store/filters.rs
index e8116d8..40d553a 100644
--- a/src/store/filters.rs
+++ b/src/store/filters.rs
@@ -12,7 +12,7 @@ pub fn evaluate_filter(filter: &FilterExpr, metadata: &Metadata) -> bool {
                 Some(fv) => evaluate_comparison(fv, op, value),
                 None => false,
             }
-        }
+        },
     }
 }
 
@@ -31,28 +31,28 @@ fn evaluate_comparison(field_value: &Value, op: &FilterOp, target: &Value) -> bo
                 (Value::Array(arr), val) => arr.contains(val),
                 _ => false,
             }
-        }
+        },
         FilterOp::In => {
             // Check if field_value is in the target array
             match target {
                 Value::Array(arr) => arr.iter().any(|v| values_equal(field_value, v)),
                 _ => false,
             }
-        }
+        },
         FilterOp::NotIn => {
             // Check if field_value is NOT in the target array
             match target {
                 Value::Array(arr) => !arr.iter().any(|v| values_equal(field_value, v)),
                 _ => true, // If target is not an array, field is "not in" it
             }
-        }
+        },
         FilterOp::StartsWith => {
             // Check if string field starts with prefix (Major Issue #13 fix)
             match (field_value, target) {
                 (Value::String(s), Value::String(prefix)) => s.starts_with(prefix.as_str()),
                 _ => false,
             }
-        }
+        },
     }
 }
 
diff --git a/src/store/hnsw_backend.rs b/src/store/hnsw_backend.rs
index 1744001..82fcd4a 100644
--- a/src/store/hnsw_backend.rs
+++ b/src/store/hnsw_backend.rs
@@ -2,15 +2,45 @@
 // Copyright 2025 VecStore Contributors
 
 use super::types::{Distance, Id};
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use hnsw_rs::api::AnnT;
 use hnsw_rs::prelude::{
-    Hnsw, DistCosine, DistL2, DistDot, DistL1,
-    Distance as HnswDistance,
+    DistCosine, DistDot, DistL1, DistL2, Distance as HnswDistance, Hnsw, Neighbour,
 };
 use std::collections::HashMap;
 use std::path::Path;
 
+/// Enumerate the index when the caller asks for every raw node. In a small
+/// randomly layered HNSW graph, approximate traversal can omit a node even
+/// when `k` and `ef` exceed the population. That is not a useful approximation
+/// for a full-population request (including over-fetches used for deletions).
+fn search_hnsw<D: HnswDistance<f32> + Send + Sync>(
+    hnsw: &Hnsw<'_, f32, D>,
+    vector: &[f32],
+    k: usize,
+    ef: usize,
+) -> Vec<Neighbour> {
+    if k == 0 || hnsw.get_nb_point() == 0 {
+        return Vec::new();
+    }
+    if k < hnsw.get_nb_point() {
+        return hnsw.search(vector, k, ef);
+    }
+    let mut neighbors: Vec<_> = hnsw
+        .get_point_indexation()
+        .into_iter()
+        .map(|point| {
+            Neighbour::new(
+                point.get_origin_id(),
+                hnsw.get_distance().eval(vector, point.get_v()),
+                point.get_point_id(),
+            )
+        })
+        .collect();
+    neighbors.sort_by(|a, b| a.distance.total_cmp(&b.distance).then(a.d_id.cmp(&b.d_id)));
+    neighbors
+}
+
 // ============================================================================
 // CUSTOM DISTANCE METRICS FOR F32 VECTORS
 // ============================================================================
@@ -26,7 +56,8 @@ impl HnswDistance<f32> for DistHammingF32 {
             return 0.0;
         }
         let threshold = 0.5;
-        let diff_count: usize = a.iter()
+        let diff_count: usize = a
+            .iter()
             .zip(b.iter())
             .filter(|&(x, y)| {
                 // Convert to binary: > threshold = 1, <= threshold = 0
@@ -94,11 +125,7 @@ impl HnswDistance<f32> for DistCanberra {
             .map(|(x, y)| {
                 let diff = (x - y).abs();
                 let sum = x.abs() + y.abs();
-                if sum > f32::EPSILON {
-                    diff / sum
-                } else {
-                    0.0
-                }
+                if sum > f32::EPSILON { diff / sum } else { 0.0 }
             })
             .sum()
     }
@@ -110,7 +137,8 @@ pub struct DistBrayCurtis;
 
 impl HnswDistance<f32> for DistBrayCurtis {
     fn eval(&self, a: &[f32], b: &[f32]) -> f32 {
-        let (diff_sum, total_sum) = a.iter()
+        let (diff_sum, total_sum) = a
+            .iter()
             .zip(b.iter())
             .fold((0.0_f32, 0.0_f32), |(d, t), (x, y)| {
                 (d + (x - y).abs(), t + x.abs() + y.abs())
@@ -216,9 +244,9 @@ impl HnswBackend {
     pub fn with_config(dimension: usize, distance: Distance, config: HnswConfig) -> Result<Self> {
         let hnsw = match distance {
             Distance::Cosine => HnswInstance::Cosine(Hnsw::<f32, DistCosine>::new(
-                config.m,              // max_nb_connection
-                config.max_elements,   // max_elements
-                config.m,              // max_layer (typically same as M)
+                config.m,               // max_nb_connection
+                config.max_elements,    // max_elements
+                config.m,               // max_layer (typically same as M)
                 config.ef_construction, // ef_construction
                 DistCosine,
             )),
@@ -400,15 +428,15 @@ impl HnswBackend {
         }
 
         let neighbors = match &self.hnsw {
-            HnswInstance::Cosine(h) => h.search(vector, k, 30),
-            HnswInstance::Euclidean(h) => h.search(vector, k, 30),
-            HnswInstance::DotProduct(h) => h.search(vector, k, 30),
-            HnswInstance::Manhattan(h) => h.search(vector, k, 30),
-            HnswInstance::Hamming(h) => h.search(vector, k, 30),
-            HnswInstance::Jaccard(h) => h.search(vector, k, 30),
-            HnswInstance::Chebyshev(h) => h.search(vector, k, 30),
-            HnswInstance::Canberra(h) => h.search(vector, k, 30),
-            HnswInstance::BrayCurtis(h) => h.search(vector, k, 30),
+            HnswInstance::Cosine(h) => search_hnsw(h, vector, k, 30),
+            HnswInstance::Euclidean(h) => search_hnsw(h, vector, k, 30),
+            HnswInstance::DotProduct(h) => search_hnsw(h, vector, k, 30),
+            HnswInstance::Manhattan(h) => search_hnsw(h, vector, k, 30),
+            HnswInstance::Hamming(h) => search_hnsw(h, vector, k, 30),
+            HnswInstance::Jaccard(h) => search_hnsw(h, vector, k, 30),
+            HnswInstance::Chebyshev(h) => search_hnsw(h, vector, k, 30),
+            HnswInstance::Canberra(h) => search_hnsw(h, vector, k, 30),
+            HnswInstance::BrayCurtis(h) => search_hnsw(h, vector, k, 30),
         };
 
         neighbors
@@ -420,14 +448,14 @@ impl HnswBackend {
                         // Similarity metrics: higher raw value = more similar
                         Distance::Cosine | Distance::DotProduct => neighbor.distance,
                         // Distance metrics: lower raw value = more similar, invert for score
-                        Distance::Euclidean | Distance::Manhattan | Distance::Chebyshev
-                        | Distance::Canberra => {
-                            1.0 / (1.0 + neighbor.distance)
-                        }
+                        Distance::Euclidean
+                        | Distance::Manhattan
+                        | Distance::Chebyshev
+                        | Distance::Canberra => 1.0 / (1.0 + neighbor.distance),
                         // Normalized distance metrics [0,1]: convert to similarity
                         Distance::Hamming | Distance::Jaccard | Distance::BrayCurtis => {
                             1.0 - neighbor.distance.clamp(0.0, 1.0)
-                        }
+                        },
                     };
                     (id.clone(), score)
                 })
@@ -480,7 +508,14 @@ impl HnswBackend {
         idx_to_id: HashMap<usize, Id>,
         next_idx: usize,
     ) -> Result<Self> {
-        Self::restore_with_config(dimension, distance, id_to_idx, idx_to_id, next_idx, HnswConfig::default())
+        Self::restore_with_config(
+            dimension,
+            distance,
+            id_to_idx,
+            idx_to_id,
+            next_idx,
+            HnswConfig::default(),
+        )
     }
 
     pub fn restore_with_config(
@@ -708,15 +743,15 @@ impl HnswBackend {
         }
 
         let neighbors = match &self.hnsw {
-            HnswInstance::Cosine(h) => h.search(vector, k, ef_search),
-            HnswInstance::Euclidean(h) => h.search(vector, k, ef_search),
-            HnswInstance::DotProduct(h) => h.search(vector, k, ef_search),
-            HnswInstance::Manhattan(h) => h.search(vector, k, ef_search),
-            HnswInstance::Hamming(h) => h.search(vector, k, ef_search),
-            HnswInstance::Jaccard(h) => h.search(vector, k, ef_search),
-            HnswInstance::Chebyshev(h) => h.search(vector, k, ef_search),
-            HnswInstance::Canberra(h) => h.search(vector, k, ef_search),
-            HnswInstance::BrayCurtis(h) => h.search(vector, k, ef_search),
+            HnswInstance::Cosine(h) => search_hnsw(h, vector, k, ef_search),
+            HnswInstance::Euclidean(h) => search_hnsw(h, vector, k, ef_search),
+            HnswInstance::DotProduct(h) => search_hnsw(h, vector, k, ef_search),
+            HnswInstance::Manhattan(h) => search_hnsw(h, vector, k, ef_search),
+            HnswInstance::Hamming(h) => search_hnsw(h, vector, k, ef_search),
+            HnswInstance::Jaccard(h) => search_hnsw(h, vector, k, ef_search),
+            HnswInstance::Chebyshev(h) => search_hnsw(h, vector, k, ef_search),
+            HnswInstance::Canberra(h) => search_hnsw(h, vector, k, ef_search),
+            HnswInstance::BrayCurtis(h) => search_hnsw(h, vector, k, ef_search),
         };
 
         Ok(neighbors
@@ -728,14 +763,14 @@ impl HnswBackend {
                         // Similarity metrics: higher raw value = more similar
                         Distance::Cosine | Distance::DotProduct => neighbor.distance,
                         // Distance metrics: lower raw value = more similar, invert for score
-                        Distance::Euclidean | Distance::Manhattan | Distance::Chebyshev
-                        | Distance::Canberra => {
-                            1.0 / (1.0 + neighbor.distance)
-                        }
+                        Distance::Euclidean
+                        | Distance::Manhattan
+                        | Distance::Chebyshev
+                        | Distance::Canberra => 1.0 / (1.0 + neighbor.distance),
                         // Normalized distance metrics [0,1]: convert to similarity
                         Distance::Hamming | Distance::Jaccard | Distance::BrayCurtis => {
                             1.0 - neighbor.distance.clamp(0.0, 1.0)
-                        }
+                        },
                     };
                     (id.clone(), score)
                 })
diff --git a/src/store/mod.rs b/src/store/mod.rs
index 65bf820..df0a5b2 100644
--- a/src/store/mod.rs
+++ b/src/store/mod.rs
@@ -33,7 +33,7 @@ pub mod hybrid;
 pub mod quantization;
 mod types;
 
-pub use filter_parser::{parse_filter, ParseError as FilterParseError};
+pub use filter_parser::{ParseError as FilterParseError, parse_filter};
 pub use hybrid::{HybridQuery, TextIndex};
 pub use quantization::{PQConfig, PQVectorStore, ProductQuantizer};
 pub use types::*;
@@ -289,7 +289,9 @@ impl VecStore {
                                 let record = Record {
                                     id: id.clone(),
                                     vector: vector.clone(),
-                                    metadata: Metadata { fields: HashMap::new() },
+                                    metadata: Metadata {
+                                        fields: HashMap::new(),
+                                    },
                                     created_at: Utc::now().timestamp(),
                                     deleted: false,
                                     deleted_at: None,
@@ -297,12 +299,12 @@ impl VecStore {
                                 };
                                 records.insert(id.clone(), record);
                                 backend.insert(id, &vector)?;
-                            }
+                            },
                             LogEntry::Delete { id } => {
                                 records.remove(&id);
                                 let _ = backend.remove(&id);
-                            }
-                            _ => {} // Ignore transaction markers for now
+                            },
+                            _ => {}, // Ignore transaction markers for now
                         }
                     }
                 }
@@ -429,7 +431,9 @@ impl VecStore {
         }
 
         if self.records.is_empty() {
-            return Err(anyhow::anyhow!("Cannot train quantizer: no vectors in store"));
+            return Err(anyhow::anyhow!(
+                "Cannot train quantizer: no vectors in store"
+            ));
         }
 
         // Collect training vectors
@@ -451,12 +455,12 @@ impl VecStore {
             QuantizationConfig::Scalar8 { .. } => {
                 let sq = ScalarQuantizer8::train(&training_vectors)?;
                 disk::QuantizerState::Scalar8(sq)
-            }
+            },
 
             QuantizationConfig::Scalar4 { .. } => {
                 let sq = ScalarQuantizer4::train(&training_vectors)?;
                 disk::QuantizerState::Scalar4(sq)
-            }
+            },
 
             QuantizationConfig::Binary { use_mean_threshold } => {
                 let bq = if *use_mean_threshold {
@@ -465,7 +469,7 @@ impl VecStore {
                     BinaryQuantizer::train_sign_based(self.dimension)
                 };
                 disk::QuantizerState::Binary(bq)
-            }
+            },
 
             QuantizationConfig::Product {
                 num_subvectors,
@@ -480,7 +484,7 @@ impl VecStore {
                 let mut pq = ProductQuantizer::new(self.dimension, pq_config)?;
                 pq.train(&training_vectors)?;
                 disk::QuantizerState::Product(pq)
-            }
+            },
         };
 
         self.quantizer = Some(quantizer);
@@ -493,8 +497,6 @@ impl VecStore {
 
     /// Rebuild quantized vector representations from records
     fn rebuild_quantized_vectors(&mut self) -> Result<()> {
-        
-
         let quantizer = match &self.quantizer {
             Some(q) => q,
             None => return Ok(()),
@@ -523,8 +525,6 @@ impl VecStore {
 
     /// Encode a single vector using the trained quantizer
     fn encode_vector(&self, vector: &[f32]) -> Option<Vec<u8>> {
-        
-
         match &self.quantizer {
             None => None,
             Some(disk::QuantizerState::None) => None,
@@ -582,13 +582,15 @@ impl VecStore {
     /// # Ok::<(), anyhow::Error>(())
     /// ```
     pub fn create_metadata_index(&mut self, name: &str, config: IndexConfig) -> Result<()> {
-        self.metadata_indexes.create_index(name, config)
+        self.metadata_indexes
+            .create_index(name, config)
             .map_err(|e| anyhow::anyhow!("Failed to create index: {}", e))
     }
 
     /// Drop a metadata index
     pub fn drop_metadata_index(&mut self, name: &str) -> Result<()> {
-        self.metadata_indexes.drop_index(name)
+        self.metadata_indexes
+            .drop_index(name)
             .map_err(|e| anyhow::anyhow!("Failed to drop index: {}", e))
     }
 
@@ -604,10 +606,9 @@ impl VecStore {
         let mut indexed = 0;
         for record in self.records.values() {
             if !record.deleted {
-                let _ = self.metadata_indexes.insert(
-                    &record.metadata.fields,
-                    record.id.clone(),
-                );
+                let _ = self
+                    .metadata_indexes
+                    .insert(&record.metadata.fields, record.id.clone());
                 indexed += 1;
             }
         }
@@ -633,7 +634,8 @@ impl VecStore {
                     ef_construction: self.config.hnsw_ef_construction,
                     max_elements: self.config.hnsw_max_elements,
                 };
-                self.backend = VectorBackend::with_config(self.dimension, self.config.distance, hnsw_config)?;
+                self.backend =
+                    VectorBackend::with_config(self.dimension, self.config.distance, hnsw_config)?;
             }
             #[cfg(target_arch = "wasm32")]
             {
@@ -654,16 +656,24 @@ impl VecStore {
         if let Some(ref mut wal) = self.wal {
             let is_update = self.records.contains_key(&id);
             let entry = if is_update {
-                LogEntry::Update { id: id.clone(), vector: vector.clone() }
+                LogEntry::Update {
+                    id: id.clone(),
+                    vector: vector.clone(),
+                }
             } else {
-                LogEntry::Insert { id: id.clone(), vector: vector.clone() }
+                LogEntry::Insert {
+                    id: id.clone(),
+                    vector: vector.clone(),
+                }
             };
             wal.append(entry)?;
         }
 
         // Remove old entry from metadata indexes if updating
         if let Some(old_record) = self.records.get(&id) {
-            let _ = self.metadata_indexes.remove(&old_record.metadata.fields, &id);
+            let _ = self
+                .metadata_indexes
+                .remove(&old_record.metadata.fields, &id);
         }
 
         let record = Record {
@@ -764,28 +774,30 @@ impl VecStore {
 
         // Set dimension from first record if needed
         if self.dimension == 0
-            && let Some(first) = items.first() {
-                // Validate first vector is non-empty (Major Issue #21 fix)
-                if first.vector.is_empty() {
-                    return Err(anyhow::anyhow!(
-                        "Cannot insert zero-dimension vector. Vectors must have at least one dimension."
-                    ));
-                }
-                self.dimension = first.vector.len();
-                #[cfg(not(target_arch = "wasm32"))]
-                {
-                    let hnsw_config = HnswConfig {
-                        m: self.config.hnsw_m,
-                        ef_construction: self.config.hnsw_ef_construction,
-                        max_elements: self.config.hnsw_max_elements,
-                    };
-                    self.backend = VectorBackend::with_config(self.dimension, self.config.distance, hnsw_config)?;
-                }
-                #[cfg(target_arch = "wasm32")]
-                {
-                    self.backend = VectorBackend::new(self.dimension);
-                }
+            && let Some(first) = items.first()
+        {
+            // Validate first vector is non-empty (Major Issue #21 fix)
+            if first.vector.is_empty() {
+                return Err(anyhow::anyhow!(
+                    "Cannot insert zero-dimension vector. Vectors must have at least one dimension."
+                ));
+            }
+            self.dimension = first.vector.len();
+            #[cfg(not(target_arch = "wasm32"))]
+            {
+                let hnsw_config = HnswConfig {
+                    m: self.config.hnsw_m,
+                    ef_construction: self.config.hnsw_ef_construction,
+                    max_elements: self.config.hnsw_max_elements,
+                };
+                self.backend =
+                    VectorBackend::with_config(self.dimension, self.config.distance, hnsw_config)?;
+            }
+            #[cfg(target_arch = "wasm32")]
+            {
+                self.backend = VectorBackend::new(self.dimension);
             }
+        }
 
         // Validate all vectors in parallel (Major Issue #21 fix)
         items.par_iter().try_for_each(|record| {
@@ -890,9 +902,10 @@ impl VecStore {
 
                 // Apply filter if present
                 if let Some(ref filter) = q.filter
-                    && !filters::evaluate_filter(filter, &record.metadata) {
-                        continue;
-                    }
+                    && !filters::evaluate_filter(filter, &record.metadata)
+                {
+                    continue;
+                }
 
                 results.push(Neighbor {
                     id: id.clone(),
@@ -993,7 +1006,12 @@ impl VecStore {
                 let explanation_text = if has_filter {
                     format!(
                         "Ranked #{} with score {:.4} ({}). Passed filters. {} candidates evaluated, {} filtered out, {} deleted.",
-                        rank, score, distance_metric, total_candidates, filtered_out_count, deleted_count
+                        rank,
+                        score,
+                        distance_metric,
+                        total_candidates,
+                        filtered_out_count,
+                        deleted_count
                     )
                 } else {
                     format!(
@@ -1150,9 +1168,7 @@ impl VecStore {
     ///
     /// Returns records that exist and are not soft-deleted.
     pub fn get_many(&self, ids: &[&str]) -> Vec<&Record> {
-        ids.iter()
-            .filter_map(|id| self.get(id))
-            .collect()
+        ids.iter().filter_map(|id| self.get(id)).collect()
     }
 
     /// Create a named snapshot of the current store state
@@ -1454,9 +1470,10 @@ impl VecStore {
 
                 // Apply filter if present
                 if let Some(ref filter) = query.filter
-                    && !filters::evaluate_filter(filter, &record.metadata) {
-                        continue;
-                    }
+                    && !filters::evaluate_filter(filter, &record.metadata)
+                {
+                    continue;
+                }
 
                 results.push(Neighbor {
                     id: id.clone(),
@@ -1503,17 +1520,18 @@ impl VecStore {
     /// * `Ok(false)` if record doesn't exist or was already deleted
     pub fn soft_delete(&mut self, id: &str) -> Result<bool> {
         if let Some(record) = self.records.get_mut(id)
-            && !record.deleted {
-                // Log to WAL before applying (for crash recovery)
-                #[cfg(not(target_arch = "wasm32"))]
-                if let Some(ref mut wal) = self.wal {
-                    wal.append(LogEntry::SoftDelete { id: id.to_string() })?;
-                }
-
-                record.deleted = true;
-                record.deleted_at = Some(Utc::now().timestamp());
-                return Ok(true);
+            && !record.deleted
+        {
+            // Log to WAL before applying (for crash recovery)
+            #[cfg(not(target_arch = "wasm32"))]
+            if let Some(ref mut wal) = self.wal {
+                wal.append(LogEntry::SoftDelete { id: id.to_string() })?;
             }
+
+            record.deleted = true;
+            record.deleted_at = Some(Utc::now().timestamp());
+            return Ok(true);
+        }
         Ok(false)
     }
 
@@ -1527,17 +1545,18 @@ impl VecStore {
     /// * `Ok(false)` if record doesn't exist or wasn't deleted
     pub fn restore(&mut self, id: &str) -> Result<bool> {
         if let Some(record) = self.records.get_mut(id)
-            && record.deleted {
-                // Log to WAL before applying (for crash recovery)
-                #[cfg(not(target_arch = "wasm32"))]
-                if let Some(ref mut wal) = self.wal {
-                    wal.append(LogEntry::Restore { id: id.to_string() })?;
-                }
-
-                record.deleted = false;
-                record.deleted_at = None;
-                return Ok(true);
+            && record.deleted
+        {
+            // Log to WAL before applying (for crash recovery)
+            #[cfg(not(target_arch = "wasm32"))]
+            if let Some(ref mut wal) = self.wal {
+                wal.append(LogEntry::Restore { id: id.to_string() })?;
             }
+
+            record.deleted = false;
+            record.deleted_at = None;
+            return Ok(true);
+        }
         Ok(false)
     }
 
@@ -1645,7 +1664,7 @@ impl VecStore {
                     .map_err(|e| (format!("upsert({})", id), e)),
                 BatchOperation::Delete { id } => {
                     self.remove(id).map_err(|e| (format!("delete({})", id), e))
-                }
+                },
                 BatchOperation::SoftDelete { id } => self
                     .soft_delete(id)
                     .map(|_| ())
@@ -1664,7 +1683,7 @@ impl VecStore {
                             anyhow::anyhow!("Record not found: {}", id),
                         ))
                     }
-                }
+                },
             };
 
             match result {
@@ -1676,7 +1695,7 @@ impl VecStore {
                         operation,
                         error: error.to_string(),
                     });
-                }
+                },
             }
         }
 
@@ -1950,11 +1969,13 @@ impl VecStore {
 
         for record in self.records.values_mut() {
             if let Some(expires_at) = record.expires_at
-                && !record.deleted && now >= expires_at {
-                    record.deleted = true;
-                    record.deleted_at = Some(now);
-                    expired_count += 1;
-                }
+                && !record.deleted
+                && now >= expires_at
+            {
+                record.deleted = true;
+                record.deleted_at = Some(now);
+                expired_count += 1;
+            }
         }
 
         Ok(expired_count)
@@ -2003,7 +2024,8 @@ impl VecStore {
                     ef_construction: self.config.hnsw_ef_construction,
                     max_elements: self.config.hnsw_max_elements,
                 };
-                self.backend = VectorBackend::with_config(self.dimension, self.config.distance, hnsw_config)?;
+                self.backend =
+                    VectorBackend::with_config(self.dimension, self.config.distance, hnsw_config)?;
             }
             #[cfg(target_arch = "wasm32")]
             {
@@ -2081,22 +2103,22 @@ impl VecStore {
             match first_stage {
                 QueryStage::VectorSearch { .. } | QueryStage::HybridSearch { .. } => {
                     // Valid first stage
-                }
+                },
                 QueryStage::Rerank { .. } => {
                     return Err(anyhow::anyhow!(
                         "First stage must be VectorSearch or HybridSearch, not Rerank. Rerank requires previous search results."
                     ));
-                }
+                },
                 QueryStage::MMR { .. } => {
                     return Err(anyhow::anyhow!(
                         "First stage must be VectorSearch or HybridSearch, not MMR. MMR requires previous search results."
                     ));
-                }
+                },
                 QueryStage::Filter { .. } => {
                     return Err(anyhow::anyhow!(
                         "First stage must be VectorSearch or HybridSearch, not Filter. Filter requires previous search results."
                     ));
-                }
+                },
             }
         }
 
@@ -2111,7 +2133,7 @@ impl VecStore {
                         k: *k,
                         filter: filter.clone(),
                     })?
-                }
+                },
 
                 QueryStage::HybridSearch {
                     vector,
@@ -2128,7 +2150,7 @@ impl VecStore {
                         alpha: *alpha,
                         filter: filter.clone(),
                     })?
-                }
+                },
 
                 QueryStage::Rerank { k, model: _ } => {
                     // Stage 2+: Rerank existing candidates
@@ -2148,7 +2170,7 @@ impl VecStore {
                     // This is a reasonable fallback when no cross-encoder is configured.
                     candidates.truncate(*k);
                     candidates
-                }
+                },
 
                 QueryStage::MMR { k, lambda } => {
                     // Stage 2+: Maximal Marginal Relevance for diversity
@@ -2160,7 +2182,7 @@ impl VecStore {
                     }
 
                     self.apply_mmr(&candidates, *k, *lambda)?
-                }
+                },
 
                 QueryStage::Filter { expr } => {
                     // Stage 2+: Additional filtering
@@ -2181,7 +2203,7 @@ impl VecStore {
                             }
                         })
                         .collect()
-                }
+                },
             };
         }
 
@@ -2365,9 +2387,9 @@ impl VecStore {
     ///     println!("  Step {}: {} (cost: {:.2})", step.step, step.description, step.cost);
     /// }
     ///
-/// for rec in plan.recommendations {
-///     println!("Hint: {}", rec);
-/// }
+    /// for rec in plan.recommendations {
+    ///     println!("Hint: {}", rec);
+    /// }
     /// # Ok::<(), anyhow::Error>(())
     /// ```
     pub fn explain_query(&self, q: Query) -> Result<QueryPlan> {
@@ -2543,7 +2565,7 @@ impl VecStore {
                     .iter()
                     .map(|e| self.estimate_filter_selectivity(e))
                     .product()
-            }
+            },
             FilterExpr::Or(exprs) => {
                 // Or: add selectivities, capped at 1.0 (more records pass)
                 let sum: f32 = exprs
@@ -2551,24 +2573,24 @@ impl VecStore {
                     .map(|e| self.estimate_filter_selectivity(e))
                     .sum();
                 sum.min(1.0)
-            }
+            },
             FilterExpr::Not(expr) => {
                 // Not: invert selectivity
                 1.0 - self.estimate_filter_selectivity(expr)
-            }
+            },
             FilterExpr::Cmp { op, .. } => {
                 // Estimate based on operator type
                 match op {
-                    FilterOp::Eq => 0.05,        // 5% - exact match is selective
-                    FilterOp::Neq => 0.95,       // 95% - inequality is not selective
-                    FilterOp::Lt | FilterOp::Gt => 0.30, // 30% - typical range
+                    FilterOp::Eq => 0.05,                  // 5% - exact match is selective
+                    FilterOp::Neq => 0.95,                 // 95% - inequality is not selective
+                    FilterOp::Lt | FilterOp::Gt => 0.30,   // 30% - typical range
                     FilterOp::Lte | FilterOp::Gte => 0.35, // 35% - inclusive range
-                    FilterOp::Contains => 0.20,  // 20% - substring matching
-                    FilterOp::In => 0.15,        // 15% - depends on list size
-                    FilterOp::NotIn => 0.85,     // 85% - inverse of In
-                    FilterOp::StartsWith => 0.10, // 10% - prefix matching
+                    FilterOp::Contains => 0.20,            // 20% - substring matching
+                    FilterOp::In => 0.15,                  // 15% - depends on list size
+                    FilterOp::NotIn => 0.85,               // 85% - inverse of In
+                    FilterOp::StartsWith => 0.10,          // 10% - prefix matching
                 }
-            }
+            },
         }
     }
 
@@ -2736,6 +2758,25 @@ mod soft_delete_tests {
         assert_eq!(store.active_count(), 3);
     }
 
+    #[test]
+    fn test_full_query_survives_random_hnsw_layers_and_restores() {
+        for _ in 0..64 {
+            let (mut store, _temp_dir) = create_test_store();
+            let query = Query {
+                vector: vec![1.0, 2.0, 3.0],
+                k: 10,
+                filter: None,
+            };
+            assert_eq!(store.query(query.clone()).unwrap().len(), 3);
+            store.soft_delete("doc1").unwrap();
+            let results = store.query(query.clone()).unwrap();
+            assert_eq!(results.len(), 2);
+            assert!(results.iter().all(|n| n.id != "doc1"));
+            store.restore("doc1").unwrap();
+            assert_eq!(store.query(query).unwrap().len(), 3);
+        }
+    }
+
     #[test]
     fn test_query_excludes_deleted() {
         let (mut store, _temp_dir) = create_test_store();
@@ -2850,9 +2891,15 @@ mod builder_tests {
             .unwrap();
 
         assert_eq!(store.distance_metric(), Distance::Manhattan);
-        store.upsert("a".to_string(), vec![1.0, 0.0, 0.0], Metadata::default()).unwrap();
-        store.upsert("b".to_string(), vec![0.0, 1.0, 0.0], Metadata::default()).unwrap();
-        let hits = store.query(Query::new(vec![1.0, 0.0, 0.0]).with_limit(2)).unwrap();
+        store
+            .upsert("a".to_string(), vec![1.0, 0.0, 0.0], Metadata::default())
+            .unwrap();
+        store
+            .upsert("b".to_string(), vec![0.0, 1.0, 0.0], Metadata::default())
+            .unwrap();
+        let hits = store
+            .query(Query::new(vec![1.0, 0.0, 0.0]).with_limit(2))
+            .unwrap();
         assert_eq!(hits.first().map(|n| n.id.as_str()), Some("a"));
     }
 
@@ -2866,9 +2913,15 @@ mod builder_tests {
             .unwrap();
 
         assert_eq!(store.distance_metric(), Distance::Hamming);
-        store.upsert("a".to_string(), vec![1.0, 0.0, 0.0], Metadata::default()).unwrap();
-        store.upsert("b".to_string(), vec![0.0, 1.0, 0.0], Metadata::default()).unwrap();
-        let hits = store.query(Query::new(vec![1.0, 0.0, 0.0]).with_limit(2)).unwrap();
+        store
+            .upsert("a".to_string(), vec![1.0, 0.0, 0.0], Metadata::default())
+            .unwrap();
+        store
+            .upsert("b".to_string(), vec![0.0, 1.0, 0.0], Metadata::default())
+            .unwrap();
+        let hits = store
+            .query(Query::new(vec![1.0, 0.0, 0.0]).with_limit(2))
+            .unwrap();
         assert_eq!(hits.first().map(|n| n.id.as_str()), Some("a"));
     }
 
@@ -2882,9 +2935,15 @@ mod builder_tests {
             .unwrap();
 
         assert_eq!(store.distance_metric(), Distance::Jaccard);
-        store.upsert("a".to_string(), vec![1.0, 0.0, 0.0], Metadata::default()).unwrap();
-        store.upsert("b".to_string(), vec![0.0, 1.0, 0.0], Metadata::default()).unwrap();
-        let hits = store.query(Query::new(vec![1.0, 0.0, 0.0]).with_limit(2)).unwrap();
+        store
+            .upsert("a".to_string(), vec![1.0, 0.0, 0.0], Metadata::default())
+            .unwrap();
+        store
+            .upsert("b".to_string(), vec![0.0, 1.0, 0.0], Metadata::default())
+            .unwrap();
+        let hits = store
+            .query(Query::new(vec![1.0, 0.0, 0.0]).with_limit(2))
+            .unwrap();
         assert_eq!(hits.first().map(|n| n.id.as_str()), Some("a"));
     }
 
diff --git a/src/store/quantization.rs b/src/store/quantization.rs
index 4c10319..883eaff 100644
--- a/src/store/quantization.rs
+++ b/src/store/quantization.rs
@@ -10,7 +10,7 @@
 // 4. During search, use asymmetric distance computation with precomputed tables
 
 use super::types::Id;
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use rand::seq::IndexedRandom;
 
 #[cfg(not(target_arch = "wasm32"))]
diff --git a/src/store/types.rs b/src/store/types.rs
index db08664..7957856 100644
--- a/src/store/types.rs
+++ b/src/store/types.rs
@@ -26,8 +26,7 @@ pub type Id = String;
 /// | Scalar4 | 8x | 96% | 3x | Large datasets |
 /// | Binary | 32x | 90% | 8x | High-dim embeddings (1024+) |
 /// | ProductQuantization | 32x | 70-90% | 0.5x | Maximum compression |
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[derive(Default)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
 pub enum QuantizationConfig {
     /// No quantization - full float32 vectors
     #[default]
@@ -109,7 +108,6 @@ const fn default_pq_iterations() -> usize {
     DEFAULT_PQ_ITERATIONS
 }
 
-
 /// Statistics about quantized vector storage
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct QuantizationStats {
@@ -168,7 +166,7 @@ impl QuantizationConfig {
                 // Original: 128 * 4 bytes = 512 bytes
                 // Compressed: num_subvectors * 1 byte
                 512.0 / *num_subvectors as f32
-            }
+            },
         }
     }
 
@@ -176,10 +174,18 @@ impl QuantizationConfig {
     pub fn description(&self) -> &'static str {
         match self {
             QuantizationConfig::None => "No quantization (full precision)",
-            QuantizationConfig::Scalar8 { .. } => "8-bit scalar quantization (4x compression, 99% recall)",
-            QuantizationConfig::Scalar4 { .. } => "4-bit scalar quantization (8x compression, 96% recall)",
-            QuantizationConfig::Binary { .. } => "Binary quantization (32x compression, 90% recall)",
-            QuantizationConfig::Product { .. } => "Product quantization (variable compression, 70-90% recall)",
+            QuantizationConfig::Scalar8 { .. } => {
+                "8-bit scalar quantization (4x compression, 99% recall)"
+            },
+            QuantizationConfig::Scalar4 { .. } => {
+                "4-bit scalar quantization (8x compression, 96% recall)"
+            },
+            QuantizationConfig::Binary { .. } => {
+                "Binary quantization (32x compression, 90% recall)"
+            },
+            QuantizationConfig::Product { .. } => {
+                "Product quantization (variable compression, 70-90% recall)"
+            },
         }
     }
 
@@ -189,7 +195,9 @@ impl QuantizationConfig {
             self,
             QuantizationConfig::Scalar8 { .. }
                 | QuantizationConfig::Scalar4 { .. }
-                | QuantizationConfig::Binary { use_mean_threshold: true }
+                | QuantizationConfig::Binary {
+                    use_mean_threshold: true
+                }
                 | QuantizationConfig::Product { .. }
         )
     }
diff --git a/src/store/wasm_hnsw.rs b/src/store/wasm_hnsw.rs
index cc35cf9..6e732c1 100644
--- a/src/store/wasm_hnsw.rs
+++ b/src/store/wasm_hnsw.rs
@@ -198,21 +198,23 @@ impl WasmHnsw {
             for neighbor_id in &neighbors_to_add {
                 // Add edge from new node to neighbor
                 if let Some(node) = self.nodes.get_mut(&id)
-                    && lc < node.neighbors.len() {
-                        node.neighbors[lc].insert(neighbor_id.clone());
-                    }
+                    && lc < node.neighbors.len()
+                {
+                    node.neighbors[lc].insert(neighbor_id.clone());
+                }
 
                 // Add edge from neighbor to new node
                 if let Some(neighbor_node) = self.nodes.get_mut(neighbor_id)
-                    && lc < neighbor_node.neighbors.len() {
-                        neighbor_node.neighbors[lc].insert(id.clone());
-
-                        // Prune neighbor's connections if exceeded max
-                        let max_conn = if lc == 0 { self.m_max } else { self.m };
-                        if neighbor_node.neighbors[lc].len() > max_conn {
-                            self.prune_connections(neighbor_id, lc, max_conn);
-                        }
+                    && lc < neighbor_node.neighbors.len()
+                {
+                    neighbor_node.neighbors[lc].insert(id.clone());
+
+                    // Prune neighbor's connections if exceeded max
+                    let max_conn = if lc == 0 { self.m_max } else { self.m };
+                    if neighbor_node.neighbors[lc].len() > max_conn {
+                        self.prune_connections(neighbor_id, lc, max_conn);
                     }
+                }
             }
 
             nearest = candidates;
@@ -275,9 +277,10 @@ impl WasmHnsw {
             for (layer, neighbor_ids) in node.neighbors.iter().enumerate() {
                 for neighbor_id in neighbor_ids {
                     if let Some(neighbor) = self.nodes.get_mut(neighbor_id)
-                        && layer < neighbor.neighbors.len() {
-                            neighbor.neighbors[layer].remove(id);
-                        }
+                        && layer < neighbor.neighbors.len()
+                    {
+                        neighbor.neighbors[layer].remove(id);
+                    }
                 }
             }
 
@@ -325,36 +328,35 @@ impl WasmHnsw {
 
             // Get node neighbors at this layer
             if let Some(node) = self.nodes.get(&current.id)
-                && layer < node.neighbors.len() {
-                    for neighbor_id in &node.neighbors[layer] {
-                        if visited.insert(neighbor_id.clone())
-                            && let Some(neighbor_node) = self.nodes.get(neighbor_id) {
-                                let dist = self.compute_distance(query, &neighbor_node.vector);
-
-                                if dist < worst_best || best.len() < num_closest {
-                                    let cand = Candidate {
-                                        id: neighbor_id.clone(),
-                                        distance: dist,
-                                    };
-                                    candidates.push(cand.clone());
-                                    best.push(cand);
-
-                                    // Keep only num_closest best
-                                    if best.len() > num_closest {
-                                        best.pop();
-                                    }
-                                }
+                && layer < node.neighbors.len()
+            {
+                for neighbor_id in &node.neighbors[layer] {
+                    if visited.insert(neighbor_id.clone())
+                        && let Some(neighbor_node) = self.nodes.get(neighbor_id)
+                    {
+                        let dist = self.compute_distance(query, &neighbor_node.vector);
+
+                        if dist < worst_best || best.len() < num_closest {
+                            let cand = Candidate {
+                                id: neighbor_id.clone(),
+                                distance: dist,
+                            };
+                            candidates.push(cand.clone());
+                            best.push(cand);
+
+                            // Keep only num_closest best
+                            if best.len() > num_closest {
+                                best.pop();
                             }
+                        }
                     }
                 }
+            }
         }
 
         // Convert to sorted vec (best first)
         let mut result: Vec<_> = best.into_iter().collect();
-        result.sort_by(|a, b| {
-            a.distance
-                .total_cmp(&b.distance)
-        });
+        result.sort_by(|a, b| a.distance.total_cmp(&b.distance));
         result
     }
 
@@ -389,10 +391,7 @@ impl WasmHnsw {
                 .collect();
 
             // Sort by distance
-            candidates.sort_by(|a, b| {
-                a.distance
-                    .total_cmp(&b.distance)
-            });
+            candidates.sort_by(|a, b| a.distance.total_cmp(&b.distance));
 
             // Keep only best max_conn
             let to_keep: HashSet<_> = candidates
@@ -403,9 +402,10 @@ impl WasmHnsw {
 
             // Update neighbors
             if let Some(node) = self.nodes.get_mut(node_id)
-                && layer < node.neighbors.len() {
-                    node.neighbors[layer] = to_keep;
-                }
+                && layer < node.neighbors.len()
+            {
+                node.neighbors[layer] = to_keep;
+            }
         }
     }
 
@@ -611,7 +611,7 @@ mod tests {
         let results_after = index.search(&[3.0, 4.0], 3, 50).unwrap();
         assert!(results_after.len() >= 1); // At least one result (v1 or v3)
         assert!(results_after.len() <= 2); // At most two results
-                                           // v2 should not be in results
+        // v2 should not be in results
         for (id, _) in &results_after {
             assert_ne!(id, "v2");
         }
diff --git a/src/streaming.rs b/src/streaming.rs
index 808cf99..fdbb309 100644
--- a/src/streaming.rs
+++ b/src/streaming.rs
@@ -30,13 +30,13 @@
 //! let results = index.search(&query, 10)?;
 //! ```
 
+use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, VecDeque};
-use std::sync::{Arc, RwLock, Mutex};
-use std::time::{Duration, Instant};
+use std::sync::{Arc, Mutex, RwLock};
 use std::thread;
-use serde::{Deserialize, Serialize};
+use std::time::{Duration, Instant};
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 /// Streaming configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -61,10 +61,18 @@ pub struct StreamConfig {
     pub buffer_size: usize,
 }
 
-fn default_batch_size() -> usize { 100 }
-fn default_flush_interval() -> u64 { 100 }
-fn default_true() -> bool { true }
-fn default_buffer_size() -> usize { 10000 }
+fn default_batch_size() -> usize {
+    100
+}
+fn default_flush_interval() -> u64 {
+    100
+}
+fn default_true() -> bool {
+    true
+}
+fn default_buffer_size() -> usize {
+    10000
+}
 
 impl Default for StreamConfig {
     fn default() -> Self {
@@ -222,7 +230,9 @@ impl StreamingIndex {
                 thread::sleep(interval);
 
                 // Check shutdown
-                let Ok(shutdown_guard) = shutdown.read() else { break; };
+                let Ok(shutdown_guard) = shutdown.read() else {
+                    break;
+                };
                 if *shutdown_guard {
                     break;
                 }
@@ -230,18 +240,17 @@ impl StreamingIndex {
 
                 // Flush pending operations
                 let start = Instant::now();
-                let ops_count = Self::flush_pending(
-                    &index,
-                    &pending,
-                    &version,
-                    batch_size,
-                    conflict_strategy,
-                );
+                let ops_count =
+                    Self::flush_pending(&index, &pending, &version, batch_size, conflict_strategy);
 
                 if ops_count > 0 {
-                    let Ok(mut stats) = stats.write() else { continue; };
+                    let Ok(mut stats) = stats.write() else {
+                        continue;
+                    };
                     stats.total_flushes += 1;
-                    let Ok(index_guard) = index.read() else { continue; };
+                    let Ok(index_guard) = index.read() else {
+                        continue;
+                    };
                     stats.vectors_in_index = index_guard.len();
 
                     let latency = start.elapsed().as_secs_f64() * 1000.0;
@@ -267,7 +276,9 @@ impl StreamingIndex {
 
         // Drain up to batch_size operations
         {
-            let Ok(mut pending) = pending.lock() else { return 0; };
+            let Ok(mut pending) = pending.lock() else {
+                return 0;
+            };
             for _ in 0..batch_size {
                 if let Some(op) = pending.pop_front() {
                     ops.push(op);
@@ -284,12 +295,21 @@ impl StreamingIndex {
         let count = ops.len();
 
         // Apply operations
-        let Ok(mut index) = index.write() else { return 0; };
-        let Ok(mut version) = version.write() else { return 0; };
+        let Ok(mut index) = index.write() else {
+            return 0;
+        };
+        let Ok(mut version) = version.write() else {
+            return 0;
+        };
 
         for op in ops {
             match op {
-                Operation::Upsert { id, vector, metadata, timestamp } => {
+                Operation::Upsert {
+                    id,
+                    vector,
+                    metadata,
+                    timestamp,
+                } => {
                     let should_update = match conflict_strategy {
                         ConflictStrategy::LastWriteWins => true,
                         ConflictStrategy::FirstWriteWins => !index.contains_key(&id),
@@ -303,7 +323,9 @@ impl StreamingIndex {
                         let final_vector = if matches!(conflict_strategy, ConflictStrategy::Merge) {
                             if let Some(existing) = index.get(&id) {
                                 // Average the vectors
-                                existing.vector.iter()
+                                existing
+                                    .vector
+                                    .iter()
                                     .zip(vector.iter())
                                     .map(|(a, b)| (a + b) / 2.0)
                                     .collect()
@@ -314,18 +336,21 @@ impl StreamingIndex {
                             vector
                         };
 
-                        index.insert(id.clone(), IndexedVector {
-                            id,
-                            vector: final_vector,
-                            metadata,
-                            version: *version,
-                            updated_at: timestamp,
-                        });
+                        index.insert(
+                            id.clone(),
+                            IndexedVector {
+                                id,
+                                vector: final_vector,
+                                metadata,
+                                version: *version,
+                                updated_at: timestamp,
+                            },
+                        );
                     }
-                }
+                },
                 Operation::Delete { id, .. } => {
                     index.remove(&id);
-                }
+                },
             }
         }
 
@@ -354,7 +379,9 @@ impl StreamingIndex {
         };
 
         {
-            let mut pending = self.pending.lock()
+            let mut pending = self
+                .pending
+                .lock()
                 .map_err(|_| VecStoreError::LockError("Failed to acquire pending lock".into()))?;
             if pending.len() >= self.config.buffer_size {
                 return Err(VecStoreError::InvalidInput("Buffer full".to_string()));
@@ -362,14 +389,18 @@ impl StreamingIndex {
             pending.push_back(op);
         }
 
-        self.stats.write()
+        self.stats
+            .write()
             .map_err(|_| VecStoreError::LockError("Failed to acquire stats write lock".into()))?
             .total_upserts += 1;
-        self.stats.write()
+        self.stats
+            .write()
             .map_err(|_| VecStoreError::LockError("Failed to acquire stats write lock".into()))?
-            .pending_operations = self.pending.lock()
-                .map_err(|_| VecStoreError::LockError("Failed to acquire pending lock".into()))?
-                .len();
+            .pending_operations = self
+            .pending
+            .lock()
+            .map_err(|_| VecStoreError::LockError("Failed to acquire pending lock".into()))?
+            .len();
 
         Ok(())
     }
@@ -382,12 +413,15 @@ impl StreamingIndex {
         };
 
         {
-            let mut pending = self.pending.lock()
+            let mut pending = self
+                .pending
+                .lock()
                 .map_err(|_| VecStoreError::LockError("Failed to acquire pending lock".into()))?;
             pending.push_back(op);
         }
 
-        self.stats.write()
+        self.stats
+            .write()
             .map_err(|_| VecStoreError::LockError("Failed to acquire stats write lock".into()))?
             .total_deletes += 1;
 
@@ -411,14 +445,18 @@ impl StreamingIndex {
             }
         }
 
-        self.stats.write()
+        self.stats
+            .write()
             .map_err(|_| VecStoreError::LockError("Failed to acquire stats write lock".into()))?
             .pending_operations = 0;
-        self.stats.write()
+        self.stats
+            .write()
             .map_err(|_| VecStoreError::LockError("Failed to acquire stats write lock".into()))?
-            .vectors_in_index = self.index.read()
-                .map_err(|_| VecStoreError::LockError("Failed to acquire index read lock".into()))?
-                .len();
+            .vectors_in_index = self
+            .index
+            .read()
+            .map_err(|_| VecStoreError::LockError("Failed to acquire index read lock".into()))?
+            .len();
 
         Ok(total)
     }
@@ -432,10 +470,13 @@ impl StreamingIndex {
             });
         }
 
-        let index = self.index.read()
+        let index = self
+            .index
+            .read()
             .map_err(|_| VecStoreError::LockError("Failed to acquire index read lock".into()))?;
 
-        let mut results: Vec<StreamSearchResult> = index.values()
+        let mut results: Vec<StreamSearchResult> = index
+            .values()
             .map(|v| {
                 let score = Self::cosine_similarity(query, &v.vector);
                 StreamSearchResult {
@@ -455,7 +496,9 @@ impl StreamingIndex {
 
     /// Get a vector by ID
     pub fn get(&self, id: &str) -> Option<StreamSearchResult> {
-        let Ok(index) = self.index.read() else { return None; };
+        let Ok(index) = self.index.read() else {
+            return None;
+        };
         index.get(id).map(|v| StreamSearchResult {
             id: v.id.clone(),
             score: 1.0,
@@ -466,25 +509,33 @@ impl StreamingIndex {
 
     /// Get statistics
     pub fn stats(&self) -> StreamingStats {
-        let Ok(stats) = self.stats.read() else { return StreamingStats::default(); };
+        let Ok(stats) = self.stats.read() else {
+            return StreamingStats::default();
+        };
         stats.clone()
     }
 
     /// Get number of vectors in index
     pub fn len(&self) -> usize {
-        let Ok(index) = self.index.read() else { return 0; };
+        let Ok(index) = self.index.read() else {
+            return 0;
+        };
         index.len()
     }
 
     /// Check if index is empty
     pub fn is_empty(&self) -> bool {
-        let Ok(index) = self.index.read() else { return true; };
+        let Ok(index) = self.index.read() else {
+            return true;
+        };
         index.is_empty()
     }
 
     /// Get current version
     pub fn version(&self) -> u64 {
-        let Ok(version) = self.version.read() else { return 0; };
+        let Ok(version) = self.version.read() else {
+            return 0;
+        };
         *version
     }
 
@@ -503,7 +554,9 @@ impl StreamingIndex {
 
     /// Shutdown the streaming index
     pub fn shutdown(&self) {
-        let Ok(mut shutdown) = self.shutdown.write() else { return; };
+        let Ok(mut shutdown) = self.shutdown.write() else {
+            return;
+        };
         *shutdown = true;
     }
 }
@@ -542,14 +595,18 @@ impl StreamConsumer {
 
         for record in records {
             match record {
-                StreamRecord::Upsert { id, vector, metadata } => {
+                StreamRecord::Upsert {
+                    id,
+                    vector,
+                    metadata,
+                } => {
                     self.index.upsert(&id, vector, metadata)?;
                     count += 1;
-                }
+                },
                 StreamRecord::Delete { id } => {
                     self.index.delete(&id)?;
                     count += 1;
-                }
+                },
             }
         }
 
@@ -623,8 +680,7 @@ mod tests {
 
     #[test]
     fn test_conflict_strategy() {
-        let config = StreamConfig::new()
-            .with_conflict_strategy(ConflictStrategy::FirstWriteWins);
+        let config = StreamConfig::new().with_conflict_strategy(ConflictStrategy::FirstWriteWins);
 
         let index = StreamingIndex::new(64, config).unwrap();
 
diff --git a/src/telemetry.rs b/src/telemetry.rs
index 2bab566..c60611c 100644
--- a/src/telemetry.rs
+++ b/src/telemetry.rs
@@ -42,7 +42,7 @@
 //! ```
 
 use anyhow::Result;
-use tracing_subscriber::{fmt, EnvFilter};
+use tracing_subscriber::{EnvFilter, fmt};
 
 /// Initialize basic tracing with console output
 ///
diff --git a/src/temporal.rs b/src/temporal.rs
index f52ffd7..40cab1b 100644
--- a/src/temporal.rs
+++ b/src/temporal.rs
@@ -35,9 +35,9 @@
 //! let drift = temporal.detect_drift(&store, "category:tech")?;
 //! ```
 
-use std::collections::HashMap;
-use chrono::{DateTime, Utc, Duration};
+use chrono::{DateTime, Duration, Utc};
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 
 use crate::error::VecStoreError;
 
@@ -79,7 +79,9 @@ pub enum DecayFunction {
 
 impl Default for DecayFunction {
     fn default() -> Self {
-        DecayFunction::Exponential { half_life_hours: 168.0 } // 1 week half-life
+        DecayFunction::Exponential {
+            half_life_hours: 168.0,
+        } // 1 week half-life
     }
 }
 
@@ -95,29 +97,37 @@ impl DecayFunction {
                 } else {
                     1.0 - (age_hours / max_age_hours)
                 }
-            }
+            },
 
             DecayFunction::Exponential { half_life_hours } => {
                 2.0_f64.powf(-age_hours / half_life_hours)
-            }
+            },
 
             DecayFunction::Gaussian { scale_hours } => {
                 let ratio = age_hours / scale_hours;
                 (-ratio * ratio).exp()
-            }
+            },
 
             DecayFunction::Step { cutoff_hours } => {
-                if age_hours <= *cutoff_hours { 1.0 } else { 0.0 }
-            }
+                if age_hours <= *cutoff_hours {
+                    1.0
+                } else {
+                    0.0
+                }
+            },
 
-            DecayFunction::Custom { rate, min_weight, max_age_hours } => {
+            DecayFunction::Custom {
+                rate,
+                min_weight,
+                max_age_hours,
+            } => {
                 if age_hours >= *max_age_hours {
                     *min_weight
                 } else {
                     let decay = (-rate * age_hours).exp();
                     decay.max(*min_weight)
                 }
-            }
+            },
         }
     }
 }
@@ -371,9 +381,7 @@ impl TemporalSearch {
         }
 
         // Re-sort by adjusted score
-        results.sort_by(|a, b| {
-            b.adjusted_score.total_cmp(&a.adjusted_score)
-        });
+        results.sort_by(|a, b| b.adjusted_score.total_cmp(&a.adjusted_score));
     }
 
     /// Get vectors that existed at a specific point in time
@@ -423,12 +431,14 @@ impl TemporalSearch {
         let old_cutoff = now - window * 2;
         let new_cutoff = now - window;
 
-        let old_vectors: Vec<_> = vectors.iter()
+        let old_vectors: Vec<_> = vectors
+            .iter()
             .filter(|(_, _, t)| *t >= old_cutoff && *t < new_cutoff)
             .map(|(_, v, _)| v.clone())
             .collect();
 
-        let new_vectors: Vec<_> = vectors.iter()
+        let new_vectors: Vec<_> = vectors
+            .iter()
             .filter(|(_, _, t)| *t >= new_cutoff)
             .map(|(_, v, _)| v.clone())
             .collect();
@@ -457,7 +467,8 @@ impl TemporalSearch {
         let new_centroid = Self::calculate_centroid(&new_vectors);
 
         // Calculate centroid shift
-        let centroid_shift: Vec<f32> = old_centroid.iter()
+        let centroid_shift: Vec<f32> = old_centroid
+            .iter()
             .zip(new_centroid.iter())
             .map(|(o, n)| n - o)
             .collect();
@@ -472,7 +483,8 @@ impl TemporalSearch {
         };
 
         // Calculate per-dimension drift
-        let mut dimension_drift: Vec<DimensionDrift> = centroid_shift.iter()
+        let mut dimension_drift: Vec<DimensionDrift> = centroid_shift
+            .iter()
             .enumerate()
             .map(|(i, &shift)| {
                 let direction = if shift > 0.01 {
@@ -540,7 +552,8 @@ impl TemporalSearch {
             let bucket_start = start + bucket_duration * i as i32;
             let bucket_end = bucket_start + bucket_duration;
 
-            let count = vectors.iter()
+            let count = vectors
+                .iter()
                 .filter(|(_, t)| *t >= bucket_start && *t < bucket_end)
                 .count();
 
@@ -567,7 +580,7 @@ impl TemporalSearch {
         // Calculate stability scores (Jaccard similarity between consecutive neighborhoods)
         let mut stability_scores = Vec::new();
         for i in 1..neighbor_history.len() {
-            let prev: std::collections::HashSet<_> = neighbor_history[i-1].1.iter().collect();
+            let prev: std::collections::HashSet<_> = neighbor_history[i - 1].1.iter().collect();
             let curr: std::collections::HashSet<_> = neighbor_history[i].1.iter().collect();
 
             let intersection = prev.intersection(&curr).count();
@@ -592,10 +605,13 @@ impl TemporalSearch {
         let trend = if stability_scores.is_empty() || stability_scores.len() < 2 {
             TrendDirection::Stable
         } else {
-            let avg_stability = stability_scores.iter().sum::<f64>() / stability_scores.len() as f64;
-            let variance: f64 = stability_scores.iter()
+            let avg_stability =
+                stability_scores.iter().sum::<f64>() / stability_scores.len() as f64;
+            let variance: f64 = stability_scores
+                .iter()
                 .map(|s| (s - avg_stability).powi(2))
-                .sum::<f64>() / stability_scores.len() as f64;
+                .sum::<f64>()
+                / stability_scores.len() as f64;
 
             if variance > 0.1 {
                 TrendDirection::Volatile
@@ -671,7 +687,8 @@ impl TemporalSearch {
         let mut total_variance = 0.0;
 
         for vec in vectors {
-            let dist_sq: f32 = vec.iter()
+            let dist_sq: f32 = vec
+                .iter()
                 .zip(centroid.iter())
                 .map(|(a, b)| (a - b).powi(2))
                 .sum();
@@ -789,13 +806,17 @@ mod tests {
     #[test]
     fn test_decay_functions() {
         // Exponential decay
-        let exp = DecayFunction::Exponential { half_life_hours: 24.0 };
+        let exp = DecayFunction::Exponential {
+            half_life_hours: 24.0,
+        };
         assert!((exp.weight(0.0) - 1.0).abs() < 1e-6);
         assert!((exp.weight(24.0) - 0.5).abs() < 1e-6);
         assert!((exp.weight(48.0) - 0.25).abs() < 1e-6);
 
         // Linear decay
-        let linear = DecayFunction::Linear { max_age_hours: 100.0 };
+        let linear = DecayFunction::Linear {
+            max_age_hours: 100.0,
+        };
         assert!((linear.weight(0.0) - 1.0).abs() < 1e-6);
         assert!((linear.weight(50.0) - 0.5).abs() < 1e-6);
         assert!((linear.weight(100.0) - 0.0).abs() < 1e-6);
@@ -839,7 +860,9 @@ mod tests {
     #[test]
     fn test_temporal_weight_calculation() {
         let config = TemporalConfig {
-            decay_function: DecayFunction::Exponential { half_life_hours: 24.0 },
+            decay_function: DecayFunction::Exponential {
+                half_life_hours: 24.0,
+            },
             ..Default::default()
         };
         let mut search = TemporalSearch::new(config);
@@ -867,9 +890,17 @@ mod tests {
         // Create vectors with drift
         let vectors = vec![
             ("v1".to_string(), vec![1.0, 0.0, 0.0], old_time),
-            ("v2".to_string(), vec![0.9, 0.1, 0.0], old_time + Duration::hours(1)),
+            (
+                "v2".to_string(),
+                vec![0.9, 0.1, 0.0],
+                old_time + Duration::hours(1),
+            ),
             ("v3".to_string(), vec![0.0, 1.0, 0.0], new_time),
-            ("v4".to_string(), vec![0.1, 0.9, 0.0], new_time + Duration::hours(1)),
+            (
+                "v4".to_string(),
+                vec![0.1, 0.9, 0.0],
+                new_time + Duration::hours(1),
+            ),
         ];
 
         let report = search.detect_drift(&vectors).unwrap();
@@ -890,9 +921,18 @@ mod tests {
 
         let vectors = vec![
             ("v1".to_string(), start + Duration::minutes(30)),
-            ("v2".to_string(), start + Duration::hours(1) + Duration::minutes(30)),
-            ("v3".to_string(), start + Duration::hours(2) + Duration::minutes(30)),
-            ("v4".to_string(), start + Duration::hours(3) + Duration::minutes(30)),
+            (
+                "v2".to_string(),
+                start + Duration::hours(1) + Duration::minutes(30),
+            ),
+            (
+                "v3".to_string(),
+                start + Duration::hours(2) + Duration::minutes(30),
+            ),
+            (
+                "v4".to_string(),
+                start + Duration::hours(3) + Duration::minutes(30),
+            ),
         ];
 
         let histogram = search.generate_histogram(&vectors, start, now);
@@ -913,9 +953,18 @@ mod tests {
 
         // Stable neighborhood over time
         let history = vec![
-            (now - Duration::hours(3), vec!["a".to_string(), "b".to_string(), "c".to_string()]),
-            (now - Duration::hours(2), vec!["a".to_string(), "b".to_string(), "c".to_string()]),
-            (now - Duration::hours(1), vec!["a".to_string(), "b".to_string(), "d".to_string()]),
+            (
+                now - Duration::hours(3),
+                vec!["a".to_string(), "b".to_string(), "c".to_string()],
+            ),
+            (
+                now - Duration::hours(2),
+                vec!["a".to_string(), "b".to_string(), "c".to_string()],
+            ),
+            (
+                now - Duration::hours(1),
+                vec!["a".to_string(), "b".to_string(), "d".to_string()],
+            ),
             (now, vec!["a".to_string(), "b".to_string(), "d".to_string()]),
         ];
 
@@ -928,7 +977,9 @@ mod tests {
         let now = Utc::now();
         let query = TemporalQueryBuilder::new(vec![1.0, 0.0, 0.0])
             .k(20)
-            .with_decay(DecayFunction::Exponential { half_life_hours: 12.0 })
+            .with_decay(DecayFunction::Exponential {
+                half_life_hours: 12.0,
+            })
             .at_time(now)
             .min_weight(0.1);
 
diff --git a/src/text_splitter.rs b/src/text_splitter.rs
index b702220..aa062b8 100644
--- a/src/text_splitter.rs
+++ b/src/text_splitter.rs
@@ -624,12 +624,12 @@ impl CodeTextSplitter {
                     || trimmed.starts_with("pub enum ")
                     || trimmed.starts_with("impl ")
                     || trimmed.starts_with("trait ")
-            }
+            },
             Some("python") => {
                 trimmed.starts_with("def ")
                     || trimmed.starts_with("class ")
                     || trimmed.starts_with("async def ")
-            }
+            },
             Some("javascript") | Some("typescript") => {
                 trimmed.starts_with("function ")
                     || trimmed.starts_with("class ")
@@ -637,7 +637,7 @@ impl CodeTextSplitter {
                     || trimmed.starts_with("let ")
                     || trimmed.starts_with("async function ")
                     || trimmed.starts_with("export ")
-            }
+            },
             Some("java") | Some("c") | Some("cpp") => {
                 // Simple heuristic: look for function-like patterns
                 (trimmed.contains('(')
@@ -647,19 +647,19 @@ impl CodeTextSplitter {
                         || trimmed.contains("void")
                         || trimmed.contains("int")))
                     || trimmed.starts_with("class ")
-            }
+            },
             Some("go") => {
                 trimmed.starts_with("func ")
                     || trimmed.starts_with("type ")
                     || trimmed.starts_with("struct ")
-            }
+            },
             _ => {
                 // Language-agnostic heuristics
                 trimmed.starts_with("fn ")
                     || trimmed.starts_with("function ")
                     || trimmed.starts_with("def ")
                     || trimmed.starts_with("class ")
-            }
+            },
         }
     }
 
diff --git a/src/timeseries.rs b/src/timeseries.rs
index 9ac840f..b731b6c 100644
--- a/src/timeseries.rs
+++ b/src/timeseries.rs
@@ -44,7 +44,7 @@
 //! # }
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use chrono::{DateTime, Datelike, Timelike, Utc};
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
@@ -86,17 +86,17 @@ impl DecayFunction {
             DecayFunction::Exponential { half_life } => {
                 let lambda = std::f64::consts::LN_2 / half_life;
                 score * (-lambda * age_seconds).exp() as f32
-            }
+            },
 
             DecayFunction::Linear { max_age } => {
                 let decay = (1.0 - age_seconds / max_age).max(0.0);
                 score * decay as f32
-            }
+            },
 
             DecayFunction::Gaussian { sigma } => {
                 let exponent = -(age_seconds.powi(2)) / (2.0 * sigma.powi(2));
                 score * exponent.exp() as f32
-            }
+            },
         }
     }
 }
@@ -222,10 +222,7 @@ impl TimeSeriesIndex {
             timestamp,
         };
 
-        self.entries
-            .entry(timestamp)
-            .or_default()
-            .push(entry);
+        self.entries.entry(timestamp).or_default().push(entry);
 
         self.num_vectors += 1;
 
@@ -361,10 +358,7 @@ impl TimeSeriesIndex {
                     TemporalGroup::MonthOfYear => dt.month() as i64,
                 };
 
-                groups
-                    .entry(group_key)
-                    .or_default()
-                    .push(entry.id.clone());
+                groups.entry(group_key).or_default().push(entry.id.clone());
             }
         }
 
diff --git a/src/timetravel.rs b/src/timetravel.rs
index 02338ce..6a41276 100644
--- a/src/timetravel.rs
+++ b/src/timetravel.rs
@@ -32,12 +32,12 @@
 //! let history = index.get_history("doc1")?;
 //! ```
 
-use std::collections::{HashMap, BTreeMap};
-use std::sync::RwLock;
+use chrono::{DateTime, Duration as ChronoDuration, Utc};
 use serde::{Deserialize, Serialize};
-use chrono::{DateTime, Utc, Duration as ChronoDuration};
+use std::collections::{BTreeMap, HashMap};
+use std::sync::RwLock;
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 // ============================================================================
 // TIMESTAMP
@@ -174,7 +174,9 @@ impl VersionHistory {
     /// Prune versions older than timestamp
     pub fn prune_before(&mut self, ts: Timestamp) {
         // Keep at least one version before the cutoff for reconstruction
-        let cutoff_idx = self.versions.iter()
+        let cutoff_idx = self
+            .versions
+            .iter()
             .position(|v| v.timestamp < ts)
             .map(|i| i + 1)
             .unwrap_or(self.versions.len());
@@ -253,7 +255,9 @@ impl TimeTravelIndex {
         }
 
         let ts = Timestamp::now();
-        let mut histories = self.histories.write()
+        let mut histories = self
+            .histories
+            .write()
             .map_err(|_| VecStoreError::LockError("histories lock poisoned".into()))?;
 
         let history = histories.entry(id.to_string()).or_insert_with(|| {
@@ -280,14 +284,21 @@ impl TimeTravelIndex {
 
         // Update timestamp index
         {
-            let mut ts_idx = self.timestamp_index.write()
+            let mut ts_idx = self
+                .timestamp_index
+                .write()
                 .map_err(|_| VecStoreError::LockError("timestamp_index lock poisoned".into()))?;
-            ts_idx.entry(ts).or_insert_with(Vec::new).push(id.to_string());
+            ts_idx
+                .entry(ts)
+                .or_insert_with(Vec::new)
+                .push(id.to_string());
         }
 
         // Update stats
         {
-            let mut stats = self.stats.write()
+            let mut stats = self
+                .stats
+                .write()
                 .map_err(|_| VecStoreError::LockError("stats lock poisoned".into()))?;
             stats.total_versions += 1;
             if op == VersionOp::Insert {
@@ -297,7 +308,9 @@ impl TimeTravelIndex {
 
         // Enforce max versions
         if history.versions.len() > self.config.max_versions_per_vector {
-            history.versions.truncate(self.config.max_versions_per_vector);
+            history
+                .versions
+                .truncate(self.config.max_versions_per_vector);
         }
 
         Ok(ts)
@@ -306,7 +319,9 @@ impl TimeTravelIndex {
     /// Delete a vector
     pub fn delete(&self, id: &str) -> Result<Option<Timestamp>> {
         let ts = Timestamp::now();
-        let mut histories = self.histories.write()
+        let mut histories = self
+            .histories
+            .write()
             .map_err(|_| VecStoreError::LockError("histories lock poisoned".into()))?;
 
         if let Some(history) = histories.get_mut(id) {
@@ -322,14 +337,20 @@ impl TimeTravelIndex {
 
             // Update timestamp index
             {
-                let mut ts_idx = self.timestamp_index.write()
-                    .map_err(|_| VecStoreError::LockError("timestamp_index lock poisoned".into()))?;
-                ts_idx.entry(ts).or_insert_with(Vec::new).push(id.to_string());
+                let mut ts_idx = self.timestamp_index.write().map_err(|_| {
+                    VecStoreError::LockError("timestamp_index lock poisoned".into())
+                })?;
+                ts_idx
+                    .entry(ts)
+                    .or_insert_with(Vec::new)
+                    .push(id.to_string());
             }
 
             // Update stats
             {
-                let mut stats = self.stats.write()
+                let mut stats = self
+                    .stats
+                    .write()
                     .map_err(|_| VecStoreError::LockError("stats lock poisoned".into()))?;
                 stats.total_versions += 1;
                 stats.total_vectors = stats.total_vectors.saturating_sub(1);
@@ -343,7 +364,9 @@ impl TimeTravelIndex {
 
     /// Get current vector
     pub fn get(&self, id: &str) -> Result<Option<(Vec<f32>, Option<serde_json::Value>)>> {
-        let histories = self.histories.read()
+        let histories = self
+            .histories
+            .read()
             .map_err(|_| VecStoreError::LockError("histories lock poisoned".into()))?;
         Ok(histories.get(id).and_then(|h| {
             h.versions.first().and_then(|v| {
@@ -357,8 +380,14 @@ impl TimeTravelIndex {
     }
 
     /// Get vector at specific timestamp
-    pub fn get_at(&self, id: &str, ts: Timestamp) -> Result<Option<(Vec<f32>, Option<serde_json::Value>)>> {
-        let histories = self.histories.read()
+    pub fn get_at(
+        &self,
+        id: &str,
+        ts: Timestamp,
+    ) -> Result<Option<(Vec<f32>, Option<serde_json::Value>)>> {
+        let histories = self
+            .histories
+            .read()
             .map_err(|_| VecStoreError::LockError("histories lock poisoned".into()))?;
         Ok(histories.get(id).and_then(|h| {
             h.get_at(ts).and_then(|v| {
@@ -373,12 +402,13 @@ impl TimeTravelIndex {
 
     /// Get all vectors that existed at timestamp
     pub fn get_all_at(&self, ts: Timestamp) -> Result<Vec<(String, Vec<f32>)>> {
-        let histories = self.histories.read()
+        let histories = self
+            .histories
+            .read()
             .map_err(|_| VecStoreError::LockError("histories lock poisoned".into()))?;
-        Ok(histories.iter()
-            .filter_map(|(id, h)| {
-                h.vector_at(ts).map(|v| (id.clone(), v.clone()))
-            })
+        Ok(histories
+            .iter()
+            .filter_map(|(id, h)| h.vector_at(ts).map(|v| (id.clone(), v.clone())))
             .collect())
     }
 
@@ -401,10 +431,13 @@ impl TimeTravelIndex {
             });
         }
 
-        let histories = self.histories.read()
+        let histories = self
+            .histories
+            .read()
             .map_err(|_| VecStoreError::LockError("histories lock poisoned".into()))?;
 
-        let mut results: Vec<_> = histories.iter()
+        let mut results: Vec<_> = histories
+            .iter()
             .filter_map(|(id, h)| {
                 h.vector_at(ts).map(|v| {
                     let score = cosine_similarity(query, v);
@@ -416,7 +449,8 @@ impl TimeTravelIndex {
         results.sort_by(|a, b| b.1.total_cmp(&a.1));
         results.truncate(top_k);
 
-        Ok(results.into_iter()
+        Ok(results
+            .into_iter()
             .map(|(id, score, version_ts)| TimeTravelResult {
                 id,
                 score,
@@ -428,20 +462,22 @@ impl TimeTravelIndex {
 
     /// Get version history for a vector
     pub fn get_history(&self, id: &str) -> Result<Option<VersionHistory>> {
-        let histories = self.histories.read()
+        let histories = self
+            .histories
+            .read()
             .map_err(|_| VecStoreError::LockError("histories lock poisoned".into()))?;
         Ok(histories.get(id).cloned())
     }
 
     /// Get changes between two timestamps
-    pub fn get_changes(
-        &self,
-        from: Timestamp,
-        to: Timestamp,
-    ) -> Result<Vec<ChangeRecord>> {
-        let ts_idx = self.timestamp_index.read()
+    pub fn get_changes(&self, from: Timestamp, to: Timestamp) -> Result<Vec<ChangeRecord>> {
+        let ts_idx = self
+            .timestamp_index
+            .read()
             .map_err(|_| VecStoreError::LockError("timestamp_index lock poisoned".into()))?;
-        let histories = self.histories.read()
+        let histories = self
+            .histories
+            .read()
             .map_err(|_| VecStoreError::LockError("histories lock poisoned".into()))?;
 
         let mut changes = Vec::new();
@@ -449,13 +485,14 @@ impl TimeTravelIndex {
         for (ts, ids) in ts_idx.range(from..=to) {
             for id in ids {
                 if let Some(history) = histories.get(id)
-                    && let Some(entry) = history.versions.iter().find(|v| v.timestamp == *ts) {
-                        changes.push(ChangeRecord {
-                            id: id.clone(),
-                            timestamp: *ts,
-                            op: entry.op,
-                        });
-                    }
+                    && let Some(entry) = history.versions.iter().find(|v| v.timestamp == *ts)
+                {
+                    changes.push(ChangeRecord {
+                        id: id.clone(),
+                        timestamp: *ts,
+                        op: entry.op,
+                    });
+                }
             }
         }
 
@@ -465,9 +502,13 @@ impl TimeTravelIndex {
     /// Run garbage collection
     pub fn gc(&self) -> Result<GCResult> {
         let cutoff = Timestamp::hours_ago(self.config.max_version_age_hours as i64);
-        let mut histories = self.histories.write()
+        let mut histories = self
+            .histories
+            .write()
             .map_err(|_| VecStoreError::LockError("histories lock poisoned".into()))?;
-        let mut ts_idx = self.timestamp_index.write()
+        let mut ts_idx = self
+            .timestamp_index
+            .write()
             .map_err(|_| VecStoreError::LockError("timestamp_index lock poisoned".into()))?;
 
         let mut versions_removed = 0;
@@ -496,7 +537,9 @@ impl TimeTravelIndex {
 
     /// Get statistics
     pub fn stats(&self) -> Result<TimeTravelStats> {
-        let stats = self.stats.read()
+        let stats = self
+            .stats
+            .read()
             .map_err(|_| VecStoreError::LockError("stats lock poisoned".into()))?;
         Ok(stats.clone())
     }
@@ -574,7 +617,8 @@ impl SnapshotManager {
             description,
         };
 
-        self.snapshots.write()
+        self.snapshots
+            .write()
             .map_err(|_| VecStoreError::LockError("snapshots lock poisoned".into()))?
             .push(snapshot.clone());
         Ok(snapshot)
@@ -582,24 +626,27 @@ impl SnapshotManager {
 
     /// List all snapshots
     pub fn list(&self) -> Result<Vec<Snapshot>> {
-        let snapshots = self.snapshots.read()
+        let snapshots = self
+            .snapshots
+            .read()
             .map_err(|_| VecStoreError::LockError("snapshots lock poisoned".into()))?;
         Ok(snapshots.clone())
     }
 
     /// Get snapshot by ID
     pub fn get(&self, id: &str) -> Result<Option<Snapshot>> {
-        let snapshots = self.snapshots.read()
+        let snapshots = self
+            .snapshots
+            .read()
             .map_err(|_| VecStoreError::LockError("snapshots lock poisoned".into()))?;
-        Ok(snapshots
-            .iter()
-            .find(|s| s.id == id)
-            .cloned())
+        Ok(snapshots.iter().find(|s| s.id == id).cloned())
     }
 
     /// Delete snapshot
     pub fn delete(&self, id: &str) -> Result<bool> {
-        let mut snapshots = self.snapshots.write()
+        let mut snapshots = self
+            .snapshots
+            .write()
             .map_err(|_| VecStoreError::LockError("snapshots lock poisoned".into()))?;
         let before = snapshots.len();
         snapshots.retain(|s| s.id != id);
@@ -657,11 +704,15 @@ mod tests {
         let index = TimeTravelIndex::new(4, config).unwrap();
 
         // Insert
-        let ts1 = index.upsert("doc1", vec![1.0, 0.0, 0.0, 0.0], None).unwrap();
+        let ts1 = index
+            .upsert("doc1", vec![1.0, 0.0, 0.0, 0.0], None)
+            .unwrap();
 
         // Update
         std::thread::sleep(std::time::Duration::from_millis(10));
-        let _ts2 = index.upsert("doc1", vec![0.0, 1.0, 0.0, 0.0], None).unwrap();
+        let _ts2 = index
+            .upsert("doc1", vec![0.0, 1.0, 0.0, 0.0], None)
+            .unwrap();
 
         // Current should return updated
         let current = index.get("doc1").unwrap().unwrap();
@@ -681,8 +732,12 @@ mod tests {
         let config = TimeTravelConfig::default();
         let index = TimeTravelIndex::new(4, config).unwrap();
 
-        index.upsert("doc1", vec![1.0, 0.0, 0.0, 0.0], None).unwrap();
-        index.upsert("doc2", vec![0.0, 1.0, 0.0, 0.0], None).unwrap();
+        index
+            .upsert("doc1", vec![1.0, 0.0, 0.0, 0.0], None)
+            .unwrap();
+        index
+            .upsert("doc2", vec![0.0, 1.0, 0.0, 0.0], None)
+            .unwrap();
 
         let before_delete = Timestamp::now();
         std::thread::sleep(std::time::Duration::from_millis(10));
@@ -695,7 +750,9 @@ mod tests {
         assert_eq!(current[0].id, "doc2");
 
         // Historical search should find both
-        let historical = index.search_at(&[1.0, 0.0, 0.0, 0.0], 10, before_delete).unwrap();
+        let historical = index
+            .search_at(&[1.0, 0.0, 0.0, 0.0], 10, before_delete)
+            .unwrap();
         assert_eq!(historical.len(), 2);
     }
 }
diff --git a/src/typo_tolerance.rs b/src/typo_tolerance.rs
index 3196f66..d7b0247 100644
--- a/src/typo_tolerance.rs
+++ b/src/typo_tolerance.rs
@@ -25,9 +25,8 @@
 //! let results = search.search("quik brwon fx")?;  // Still finds the document!
 //! ```
 
-use std::collections::{HashMap, HashSet, BTreeMap};
 use serde::{Deserialize, Serialize};
-
+use std::collections::{BTreeMap, HashMap, HashSet};
 
 /// Typo tolerance configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -55,11 +54,21 @@ pub struct TypoConfig {
     pub prioritize_exact: bool,
 }
 
-fn default_short_typos() -> usize { 0 }
-fn default_medium_typos() -> usize { 1 }
-fn default_long_typos() -> usize { 2 }
-fn default_true() -> bool { true }
-fn default_min_prefix() -> usize { 2 }
+fn default_short_typos() -> usize {
+    0
+}
+fn default_medium_typos() -> usize {
+    1
+}
+fn default_long_typos() -> usize {
+    2
+}
+fn default_true() -> bool {
+    true
+}
+fn default_min_prefix() -> usize {
+    2
+}
 
 impl Default for TypoConfig {
     fn default() -> Self {
@@ -218,11 +227,14 @@ impl TypoTolerantSearch {
             }
         }
 
-        self.documents.insert(id.to_string(), IndexedDocument {
-            id: id.to_string(),
-            tokens,
-            original: text.to_string(),
-        });
+        self.documents.insert(
+            id.to_string(),
+            IndexedDocument {
+                id: id.to_string(),
+                tokens,
+                original: text.to_string(),
+            },
+        );
     }
 
     /// Remove a document from the index
@@ -291,7 +303,8 @@ impl TypoTolerantSearch {
 
         // Sort by score (descending), then by typos (ascending)
         results.sort_by(|a, b| {
-            b.score.total_cmp(&a.score)
+            b.score
+                .total_cmp(&a.score)
                 .then_with(|| a.typos.cmp(&b.typos))
         });
 
@@ -306,12 +319,15 @@ impl TypoTolerantSearch {
         // 1. Exact matches (highest priority)
         if let Some(doc_ids) = self.token_index.get(query_token) {
             for doc_id in doc_ids {
-                matches.push((doc_id.clone(), MatchedToken {
-                    query: query_token.to_string(),
-                    matched: query_token.to_string(),
-                    edit_distance: 0,
-                    match_type: MatchType::Exact,
-                }));
+                matches.push((
+                    doc_id.clone(),
+                    MatchedToken {
+                        query: query_token.to_string(),
+                        matched: query_token.to_string(),
+                        edit_distance: 0,
+                        match_type: MatchType::Exact,
+                    },
+                ));
             }
         }
 
@@ -322,14 +338,18 @@ impl TypoTolerantSearch {
             let range_end = format!("{}~", query_token); // '~' is after all alphanumeric
 
             for (prefix, doc_ids) in self.prefix_index.range(range_start..range_end) {
-                if prefix != query_token { // Avoid duplicating exact matches
+                if prefix != query_token {
+                    // Avoid duplicating exact matches
                     for doc_id in doc_ids {
-                        matches.push((doc_id.clone(), MatchedToken {
-                            query: query_token.to_string(),
-                            matched: prefix.clone(),
-                            edit_distance: 0,
-                            match_type: MatchType::Prefix,
-                        }));
+                        matches.push((
+                            doc_id.clone(),
+                            MatchedToken {
+                                query: query_token.to_string(),
+                                matched: prefix.clone(),
+                                edit_distance: 0,
+                                match_type: MatchType::Prefix,
+                            },
+                        ));
                     }
                 }
             }
@@ -341,12 +361,15 @@ impl TypoTolerantSearch {
                 let distance = self.levenshtein(query_token, token);
                 if distance > 0 && distance <= max_typos {
                     for doc_id in doc_ids {
-                        matches.push((doc_id.clone(), MatchedToken {
-                            query: query_token.to_string(),
-                            matched: token.clone(),
-                            edit_distance: distance,
-                            match_type: MatchType::Fuzzy,
-                        }));
+                        matches.push((
+                            doc_id.clone(),
+                            MatchedToken {
+                                query: query_token.to_string(),
+                                matched: token.clone(),
+                                edit_distance: distance,
+                                match_type: MatchType::Fuzzy,
+                            },
+                        ));
                     }
                 }
             }
@@ -358,12 +381,15 @@ impl TypoTolerantSearch {
             if let Some(doc_ids) = self.phonetic_index.get(&query_soundex) {
                 for doc_id in doc_ids {
                     if !matches.iter().any(|(id, _)| id == doc_id) {
-                        matches.push((doc_id.clone(), MatchedToken {
-                            query: query_token.to_string(),
-                            matched: query_soundex.clone(),
-                            edit_distance: 0,
-                            match_type: MatchType::Phonetic,
-                        }));
+                        matches.push((
+                            doc_id.clone(),
+                            MatchedToken {
+                                query: query_token.to_string(),
+                                matched: query_soundex.clone(),
+                                edit_distance: 0,
+                                match_type: MatchType::Phonetic,
+                            },
+                        ));
                     }
                 }
             }
@@ -388,8 +414,12 @@ impl TypoTolerantSearch {
         let a_len = a_chars.len();
         let b_len = b_chars.len();
 
-        if a_len == 0 { return b_len; }
-        if b_len == 0 { return a_len; }
+        if a_len == 0 {
+            return b_len;
+        }
+        if b_len == 0 {
+            return a_len;
+        }
 
         let mut matrix = vec![vec![0usize; b_len + 1]; a_len + 1];
 
@@ -402,7 +432,11 @@ impl TypoTolerantSearch {
 
         for i in 1..=a_len {
             for j in 1..=b_len {
-                let cost = if a_chars[i - 1] == b_chars[j - 1] { 0 } else { 1 };
+                let cost = if a_chars[i - 1] == b_chars[j - 1] {
+                    0
+                } else {
+                    1
+                };
 
                 matrix[i][j] = (matrix[i - 1][j] + 1)
                     .min(matrix[i][j - 1] + 1)
@@ -444,9 +478,10 @@ impl TypoTolerantSearch {
 
             let curr_code = get_code(c);
             if let Some(cc) = curr_code
-                && curr_code != prev_code {
-                    code.push(cc);
-                }
+                && curr_code != prev_code
+            {
+                code.push(cc);
+            }
             prev_code = curr_code;
         }
 
@@ -537,7 +572,12 @@ mod tests {
 
         let results = search.search("qui");
         assert!(!results.is_empty());
-        assert!(results[0].matched_tokens.iter().any(|t| t.match_type == MatchType::Prefix));
+        assert!(
+            results[0]
+                .matched_tokens
+                .iter()
+                .any(|t| t.match_type == MatchType::Prefix)
+        );
     }
 
     #[test]
diff --git a/src/validation.rs b/src/validation.rs
index e7475f7..64ba04a 100644
--- a/src/validation.rs
+++ b/src/validation.rs
@@ -32,7 +32,7 @@
 //! let fixed = validator.auto_fix(&vector)?;
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 
 /// Validation configuration
@@ -269,12 +269,13 @@ impl VectorValidator {
 
         // Check dimension
         if let Some(expected_dim) = self.config.expected_dimension
-            && vector.len() != expected_dim {
-                errors.push(ValidationError::DimensionMismatch {
-                    expected: expected_dim,
-                    actual: vector.len(),
-                });
-            }
+            && vector.len() != expected_dim
+        {
+            errors.push(ValidationError::DimensionMismatch {
+                expected: expected_dim,
+                actual: vector.len(),
+            });
+        }
 
         // Check for NaN and infinity
         let nan_indices: Vec<usize> = vector
@@ -477,7 +478,7 @@ impl VectorValidator {
 
     fn compute_variance(&self, vector: &[f32]) -> f32 {
         let mean = vector.iter().sum::<f32>() / vector.len() as f32;
-        
+
         vector.iter().map(|v| (v - mean).powi(2)).sum::<f32>() / vector.len() as f32
     }
 
@@ -557,9 +558,11 @@ mod tests {
         let result = validator.validate(&vector);
         assert!(result.is_invalid());
         if let ValidationResult::Invalid(errors) = result {
-            assert!(errors
-                .iter()
-                .any(|e| matches!(e, ValidationError::ContainsNaN { .. })));
+            assert!(
+                errors
+                    .iter()
+                    .any(|e| matches!(e, ValidationError::ContainsNaN { .. }))
+            );
         }
     }
 
@@ -578,9 +581,11 @@ mod tests {
         let result = validator.validate(&vector);
         assert!(result.is_invalid());
         if let ValidationResult::Invalid(errors) = result {
-            assert!(errors
-                .iter()
-                .any(|e| matches!(e, ValidationError::ZeroVector)));
+            assert!(
+                errors
+                    .iter()
+                    .any(|e| matches!(e, ValidationError::ZeroVector))
+            );
         }
     }
 
diff --git a/src/vectors/hybrid_search.rs b/src/vectors/hybrid_search.rs
index f018634..ea2731b 100644
--- a/src/vectors/hybrid_search.rs
+++ b/src/vectors/hybrid_search.rs
@@ -266,7 +266,7 @@ pub fn hybrid_search_score(
     match config.fusion_strategy {
         FusionStrategy::WeightedSum => {
             config.alpha * dense_score + (1.0 - config.alpha) * sparse_score
-        }
+        },
 
         FusionStrategy::ReciprocalRankFusion => {
             // Note: This is a simplified RRF for score-based fusion
@@ -275,19 +275,19 @@ pub fn hybrid_search_score(
             let dense_rank_score = 1.0 / (config.rrf_k + (1.0 - dense_score));
             let sparse_rank_score = 1.0 / (config.rrf_k + (1.0 - sparse_score));
             dense_rank_score + sparse_rank_score
-        }
+        },
 
         FusionStrategy::DistributionBased => {
             // DBSF: For single-score fusion, just average
             // Full DBSF normalization happens in normalize_scores_dbsf()
             config.alpha * dense_score + (1.0 - config.alpha) * sparse_score
-        }
+        },
 
         FusionStrategy::RelativeScore => {
             // RelativeScore: For single-score fusion, same as WeightedSum
             // Full min-max normalization happens in normalize_scores()
             config.alpha * dense_score + (1.0 - config.alpha) * sparse_score
-        }
+        },
 
         FusionStrategy::Max => dense_score.max(sparse_score),
 
@@ -299,7 +299,7 @@ pub fn hybrid_search_score(
             } else {
                 2.0 * dense_score * sparse_score / (dense_score + sparse_score)
             }
-        }
+        },
 
         FusionStrategy::GeometricMean => {
             if dense_score < 0.0 || sparse_score < 0.0 {
@@ -307,7 +307,7 @@ pub fn hybrid_search_score(
             } else {
                 (dense_score * sparse_score).sqrt()
             }
-        }
+        },
     }
 }
 
@@ -382,7 +382,7 @@ pub fn explain_hybrid_score(
             };
 
             (calc, contributions)
-        }
+        },
 
         FusionStrategy::ReciprocalRankFusion => {
             let dense_rank_score = 1.0 / (config.rrf_k + (1.0 - dense_score));
@@ -409,7 +409,7 @@ pub fn explain_hybrid_score(
             };
 
             (calc, contributions)
-        }
+        },
 
         FusionStrategy::DistributionBased | FusionStrategy::RelativeScore => {
             let dense_weight = config.alpha;
@@ -447,7 +447,7 @@ pub fn explain_hybrid_score(
             };
 
             (calc, contributions)
-        }
+        },
 
         FusionStrategy::Max => {
             let calc = format!(
@@ -476,7 +476,7 @@ pub fn explain_hybrid_score(
             };
 
             (calc, contributions)
-        }
+        },
 
         FusionStrategy::Min => {
             let calc = format!(
@@ -505,7 +505,7 @@ pub fn explain_hybrid_score(
             };
 
             (calc, contributions)
-        }
+        },
 
         FusionStrategy::HarmonicMean => {
             let calc = if dense_score + sparse_score == 0.0 {
@@ -527,7 +527,7 @@ pub fn explain_hybrid_score(
             };
 
             (calc, contributions)
-        }
+        },
 
         FusionStrategy::GeometricMean => {
             let calc = if dense_score < 0.0 || sparse_score < 0.0 {
@@ -546,7 +546,7 @@ pub fn explain_hybrid_score(
             };
 
             (calc, contributions)
-        }
+        },
     };
 
     ScoreExplanation {
@@ -1486,10 +1486,12 @@ mod tests {
         assert!(explanation.calculation.contains("Max"));
         assert_eq!(explanation.contributions.dense_contribution, 1.0);
         assert_eq!(explanation.contributions.sparse_contribution, 0.0);
-        assert!(explanation
-            .contributions
-            .explanation
-            .contains("Dense score was higher"));
+        assert!(
+            explanation
+                .contributions
+                .explanation
+                .contains("Dense score was higher")
+        );
     }
 
     #[test]
@@ -1505,10 +1507,12 @@ mod tests {
         assert!(explanation.calculation.contains("Min"));
         assert_eq!(explanation.contributions.dense_contribution, 0.0);
         assert_eq!(explanation.contributions.sparse_contribution, 1.0);
-        assert!(explanation
-            .contributions
-            .explanation
-            .contains("Sparse score was lower"));
+        assert!(
+            explanation
+                .contributions
+                .explanation
+                .contains("Sparse score was lower")
+        );
     }
 
     #[test]
@@ -1589,10 +1593,12 @@ mod tests {
         assert_eq!(explanation.final_score, 0.0);
         assert_eq!(explanation.dense_score, 0.0);
         assert_eq!(explanation.sparse_score, 0.0);
-        assert!(explanation
-            .contributions
-            .explanation
-            .contains("Both scores are zero"));
+        assert!(
+            explanation
+                .contributions
+                .explanation
+                .contains("Both scores are zero")
+        );
     }
 
     #[test]
diff --git a/src/vectors/mod.rs b/src/vectors/mod.rs
index 44f074b..b467845 100644
--- a/src/vectors/mod.rs
+++ b/src/vectors/mod.rs
@@ -15,13 +15,13 @@ pub mod ops;
 pub mod vector_types;
 
 pub use bm25::{
-    bm25_score, bm25_score_simple, bm25f_score, parse_field_weight, parse_field_weights,
-    BM25Config, BM25Stats, FieldWeights,
+    BM25Config, BM25Stats, FieldWeights, bm25_score, bm25_score_simple, bm25f_score,
+    parse_field_weight, parse_field_weights,
 };
 pub use hybrid_search::{
+    FusionStrategy, HybridQuery, HybridSearchConfig, ScoreContributions, ScoreExplanation,
     apply_autocut, explain_hybrid_score, hybrid_search_score, normalize_scores,
-    normalize_scores_dbsf, normalize_scores_zscore, FusionStrategy, HybridQuery,
-    HybridSearchConfig, ScoreContributions, ScoreExplanation,
+    normalize_scores_dbsf, normalize_scores_zscore,
 };
 pub use ops::{KMeans, VectorOps};
 pub use vector_types::Vector;
diff --git a/src/vectors/ops.rs b/src/vectors/ops.rs
index 89ae620..62923fb 100644
--- a/src/vectors/ops.rs
+++ b/src/vectors/ops.rs
@@ -142,15 +142,15 @@ impl VectorOps {
                     result += a_values[i] * b_values[j];
                     i += 1;
                     j += 1;
-                }
+                },
                 std::cmp::Ordering::Less => {
                     // a's index is smaller - advance a
                     i += 1;
-                }
+                },
                 std::cmp::Ordering::Greater => {
                     // b's index is smaller - advance b
                     j += 1;
-                }
+                },
             }
         }
 
diff --git a/src/vectors/vector_types.rs b/src/vectors/vector_types.rs
index caccffa..f51010a 100644
--- a/src/vectors/vector_types.rs
+++ b/src/vectors/vector_types.rs
@@ -12,7 +12,7 @@
 //!
 //! Hybrid vectors enable powerful fusion search strategies.
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 
 /// Vector representation supporting dense, sparse, or hybrid
@@ -103,13 +103,14 @@ impl Vector {
             ));
         }
         if let Some(&max_idx) = indices.iter().max()
-            && max_idx >= dimension {
-                return Err(anyhow!(
-                    "Sparse vector index {} out of bounds (dimension: {})",
-                    max_idx,
-                    dimension
-                ));
-            }
+            && max_idx >= dimension
+        {
+            return Err(anyhow!(
+                "Sparse vector index {} out of bounds (dimension: {})",
+                max_idx,
+                dimension
+            ));
+        }
         Ok(Vector::Sparse {
             dimension,
             indices,
@@ -211,7 +212,7 @@ impl Vector {
                 } else {
                     1.0 - (indices.len() as f32 / *dimension as f32)
                 }
-            }
+            },
             Vector::Hybrid { sparse_indices, .. } => {
                 // For hybrid, report sparsity of sparse component
                 // (not well-defined since we don't know sparse dimension)
@@ -221,7 +222,7 @@ impl Vector {
                     // Just report presence of sparse component
                     0.5
                 }
-            }
+            },
         }
     }
 
@@ -252,7 +253,7 @@ impl Vector {
                     dense[idx] = val;
                 }
                 dense
-            }
+            },
             Vector::Hybrid { dense, .. } => dense.clone(),
         }
     }
@@ -283,7 +284,7 @@ impl Vector {
                 indices.len() * size_of::<usize>()
                     + values.len() * size_of::<f32>()
                     + size_of::<usize>() // dimension field
-            }
+            },
             Vector::Hybrid {
                 dense,
                 sparse_indices,
@@ -292,7 +293,7 @@ impl Vector {
                 dense.len() * size_of::<f32>()
                     + sparse_indices.len() * size_of::<usize>()
                     + sparse_values.len() * size_of::<f32>()
-            }
+            },
         }
     }
 }
diff --git a/src/versioning.rs b/src/versioning.rs
index 8a3a08e..1304e14 100644
--- a/src/versioning.rs
+++ b/src/versioning.rs
@@ -35,7 +35,7 @@
 //! store.create_snapshot("before_experiment")?;
 //! ```
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
diff --git a/src/wal.rs b/src/wal.rs
index dba8163..a9e2bf3 100644
--- a/src/wal.rs
+++ b/src/wal.rs
@@ -149,7 +149,7 @@ impl WriteAheadLog {
             // Read length prefix
             let mut len_bytes = [0u8; 4];
             match reader.read_exact(&mut len_bytes) {
-                Ok(_) => {}
+                Ok(_) => {},
                 Err(ref e) if e.kind() == std::io::ErrorKind::UnexpectedEof => break,
                 Err(e) => return Err(e.into()),
             }
@@ -248,7 +248,7 @@ impl WriteAheadLog {
         loop {
             let mut len_bytes = [0u8; 4];
             match reader.read_exact(&mut len_bytes) {
-                Ok(_) => {}
+                Ok(_) => {},
                 Err(ref e) if e.kind() == std::io::ErrorKind::UnexpectedEof => break,
                 Err(e) => return Err(e.into()),
             }
diff --git a/src/wasm.rs b/src/wasm.rs
index 7c9d25c..ccb5016 100644
--- a/src/wasm.rs
+++ b/src/wasm.rs
@@ -7,7 +7,7 @@
 // Note: This uses an in-memory store since file I/O works differently in browsers.
 
 use crate::store::{
-    hybrid::TextIndex, parse_filter, FilterExpr, Metadata, Query, Record, VectorBackend,
+    FilterExpr, Metadata, Query, Record, VectorBackend, hybrid::TextIndex, parse_filter,
 };
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
diff --git a/src/zero_copy.rs b/src/zero_copy.rs
index 3b3ad67..392cfb8 100644
--- a/src/zero_copy.rs
+++ b/src/zero_copy.rs
@@ -35,11 +35,11 @@
 //! store.merge("experiment")?;
 //! ```
 
-use std::collections::{HashMap, HashSet, BTreeMap};
-use std::sync::{Arc, RwLock};
 use serde::{Deserialize, Serialize};
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::sync::{Arc, RwLock};
 
-use crate::error::{VecStoreError, Result};
+use crate::error::{Result, VecStoreError};
 
 // ============================================================================
 // TYPES
@@ -172,7 +172,9 @@ impl CowStorage {
         if self.deleted.contains(id) {
             return None;
         }
-        self.working.get(id).or_else(|| self.base.get(id).map(|arc| arc.as_ref()))
+        self.working
+            .get(id)
+            .or_else(|| self.base.get(id).map(|arc| arc.as_ref()))
     }
 
     /// Set a vector (copy-on-write)
@@ -277,15 +279,18 @@ impl VersionedStore {
 
         // Create initial commit
         let mut commits = BTreeMap::new();
-        commits.insert("initial".to_string(), Commit {
-            hash: "initial".to_string(),
-            parent: None,
-            message: "Initial commit".to_string(),
-            timestamp: unix_timestamp(),
-            author: None,
-            changed_ids: Vec::new(),
-            deleted_ids: Vec::new(),
-        });
+        commits.insert(
+            "initial".to_string(),
+            Commit {
+                hash: "initial".to_string(),
+                parent: None,
+                message: "Initial commit".to_string(),
+                timestamp: unix_timestamp(),
+                author: None,
+                changed_ids: Vec::new(),
+                deleted_ids: Vec::new(),
+            },
+        );
 
         Ok(Self {
             dimension,
@@ -299,7 +304,10 @@ impl VersionedStore {
 
     /// Get current branch name
     pub fn current_branch(&self) -> String {
-        self.current_branch.read().map(|b| b.clone()).unwrap_or_else(|_| "main".to_string())
+        self.current_branch
+            .read()
+            .map(|b| b.clone())
+            .unwrap_or_else(|_| "main".to_string())
     }
 
     /// Insert or update a vector
@@ -318,7 +326,8 @@ impl VersionedStore {
 
         let branch = self.current_branch.read()?.clone();
         let mut storages = self.storages.write()?;
-        let storage = storages.get_mut(&branch)
+        let storage = storages
+            .get_mut(&branch)
             .ok_or_else(|| VecStoreError::NotFound(format!("Branch: {}", branch)))?;
 
         let now = unix_timestamp();
@@ -337,7 +346,8 @@ impl VersionedStore {
     pub fn delete(&self, id: &str) -> Result<bool> {
         let branch = self.current_branch.read()?.clone();
         let mut storages = self.storages.write()?;
-        let storage = storages.get_mut(&branch)
+        let storage = storages
+            .get_mut(&branch)
             .ok_or_else(|| VecStoreError::NotFound(format!("Branch: {}", branch)))?;
 
         let existed = storage.get(id).is_some();
@@ -351,7 +361,9 @@ impl VersionedStore {
         let storages = self.storages.read().ok()?;
         let storage = storages.get(&branch)?;
 
-        storage.get(id).map(|d| (d.vector.clone(), d.metadata.clone()))
+        storage
+            .get(id)
+            .map(|d| (d.vector.clone(), d.metadata.clone()))
     }
 
     /// Create a commit
@@ -368,7 +380,8 @@ impl VersionedStore {
         // Commit storage changes
         let (changed, deleted) = {
             let mut storages = self.storages.write()?;
-            let storage = storages.get_mut(&branch_name)
+            let storage = storages
+                .get_mut(&branch_name)
                 .ok_or_else(|| VecStoreError::NotFound(format!("Branch: {}", branch_name)))?;
             storage.commit()
         };
@@ -428,7 +441,8 @@ impl VersionedStore {
         // Get current branch head
         let head = {
             let branches = self.branches.read()?;
-            branches.get(&current)
+            branches
+                .get(&current)
                 .map(|b| b.head.clone())
                 .unwrap_or_else(|| "initial".to_string())
         };
@@ -436,7 +450,8 @@ impl VersionedStore {
         // Fork storage
         let new_storage = {
             let storages = self.storages.read()?;
-            storages.get(&current)
+            storages
+                .get(&current)
                 .ok_or_else(|| VecStoreError::NotFound(format!("Branch: {}", current)))?
                 .fork()
         };
@@ -476,12 +491,13 @@ impl VersionedStore {
         {
             let current = self.current_branch.read()?.clone();
             let storages = self.storages.read()?;
-            if storages.get(&current)
+            if storages
+                .get(&current)
                 .ok_or_else(|| VecStoreError::NotFound(format!("Branch: {}", current)))?
                 .is_dirty()
             {
                 return Err(VecStoreError::InvalidInput(
-                    "Uncommitted changes - commit or reset first".to_string()
+                    "Uncommitted changes - commit or reset first".to_string(),
                 ));
             }
         }
@@ -494,20 +510,25 @@ impl VersionedStore {
     pub fn reset(&self) {
         if let Ok(branch) = self.current_branch.read().map(|b| b.clone())
             && let Ok(mut storages) = self.storages.write()
-                && let Some(storage) = storages.get_mut(&branch) {
-                    storage.reset();
-                }
+            && let Some(storage) = storages.get_mut(&branch)
+        {
+            storage.reset();
+        }
     }
 
     /// Delete a branch
     pub fn delete_branch(&self, name: &str) -> Result<bool> {
         if name == "main" {
-            return Err(VecStoreError::InvalidInput("Cannot delete main branch".to_string()));
+            return Err(VecStoreError::InvalidInput(
+                "Cannot delete main branch".to_string(),
+            ));
         }
 
         let current = self.current_branch.read()?.clone();
         if current == name {
-            return Err(VecStoreError::InvalidInput("Cannot delete current branch".to_string()));
+            return Err(VecStoreError::InvalidInput(
+                "Cannot delete current branch".to_string(),
+            ));
         }
 
         let removed = {
@@ -526,9 +547,11 @@ impl VersionedStore {
     pub fn diff(&self, from: &str, to: &str) -> Result<Diff> {
         let commits = self.commits.read()?;
 
-        let from_commit = commits.get(from)
+        let from_commit = commits
+            .get(from)
             .ok_or_else(|| VecStoreError::NotFound(format!("Commit: {}", from)))?;
-        let to_commit = commits.get(to)
+        let to_commit = commits
+            .get(to)
             .ok_or_else(|| VecStoreError::NotFound(format!("Commit: {}", to)))?;
 
         // Collect changes between commits
@@ -536,8 +559,14 @@ impl VersionedStore {
         let from_changes: HashSet<_> = from_commit.changed_ids.iter().collect();
         let to_changes: HashSet<_> = to_commit.changed_ids.iter().collect();
 
-        let added: Vec<_> = to_changes.difference(&from_changes).map(|s| (*s).clone()).collect();
-        let modified: Vec<_> = to_changes.intersection(&from_changes).map(|s| (*s).clone()).collect();
+        let added: Vec<_> = to_changes
+            .difference(&from_changes)
+            .map(|s| (*s).clone())
+            .collect();
+        let modified: Vec<_> = to_changes
+            .intersection(&from_changes)
+            .map(|s| (*s).clone())
+            .collect();
         let deleted = to_commit.deleted_ids.clone();
 
         Ok(Diff {
@@ -560,14 +589,18 @@ impl VersionedStore {
         let current = self.current_branch.read()?.clone();
 
         if current == from_branch {
-            return Err(VecStoreError::InvalidInput("Cannot merge branch into itself".to_string()));
+            return Err(VecStoreError::InvalidInput(
+                "Cannot merge branch into itself".to_string(),
+            ));
         }
 
         // Get both storages
         let storages = self.storages.read()?;
-        let from_storage = storages.get(from_branch)
+        let from_storage = storages
+            .get(from_branch)
             .ok_or_else(|| VecStoreError::NotFound(format!("Branch: {}", from_branch)))?;
-        let to_storage = storages.get(&current)
+        let to_storage = storages
+            .get(&current)
             .ok_or_else(|| VecStoreError::NotFound(format!("Branch: {}", current)))?;
 
         // Find conflicts
@@ -580,14 +613,15 @@ impl VersionedStore {
             let to_data = to_storage.get(id);
 
             if let (Some(f), Some(t)) = (from_data, to_data)
-                && f.vector != t.vector {
-                    conflicts.push(MergeConflict {
-                        id: id.clone(),
-                        conflict_type: ConflictType::ModifyModify,
-                        ours: Some(t.vector.clone()),
-                        theirs: Some(f.vector.clone()),
-                    });
-                }
+                && f.vector != t.vector
+            {
+                conflicts.push(MergeConflict {
+                    id: id.clone(),
+                    conflict_type: ConflictType::ModifyModify,
+                    ours: Some(t.vector.clone()),
+                    theirs: Some(f.vector.clone()),
+                });
+            }
         }
 
         // Handle conflicts based on resolution strategy
@@ -605,15 +639,18 @@ impl VersionedStore {
 
         // First, collect data from source branch
         let items_to_copy: Vec<(String, VectorData)> = {
-            let from_storage = storages.get(from_branch)
+            let from_storage = storages
+                .get(from_branch)
                 .ok_or_else(|| VecStoreError::NotFound(format!("Branch: {}", from_branch)))?;
-            from_ids.difference(&to_ids)
+            from_ids
+                .difference(&to_ids)
                 .filter_map(|id| from_storage.get(id).map(|data| (id.clone(), data.clone())))
                 .collect()
         };
 
         // Now apply to target branch
-        let to_storage = storages.get_mut(&current)
+        let to_storage = storages
+            .get_mut(&current)
             .ok_or_else(|| VecStoreError::NotFound(format!("Branch: {}", current)))?;
 
         // Copy new items from source
@@ -628,21 +665,29 @@ impl VersionedStore {
                 ConflictResolution::Theirs => conflict.theirs.clone(),
                 ConflictResolution::Average => {
                     if let (Some(ours), Some(theirs)) = (&conflict.ours, &conflict.theirs) {
-                        Some(ours.iter().zip(theirs).map(|(a, b)| (a + b) / 2.0).collect())
+                        Some(
+                            ours.iter()
+                                .zip(theirs)
+                                .map(|(a, b)| (a + b) / 2.0)
+                                .collect(),
+                        )
                     } else {
                         None
                     }
-                }
+                },
                 ConflictResolution::Abort => unreachable!(),
             };
 
             if let Some(vec) = resolved {
-                to_storage.set(&conflict.id, VectorData {
-                    vector: vec,
-                    metadata: None,
-                    created_at: unix_timestamp(),
-                    modified_at: unix_timestamp(),
-                });
+                to_storage.set(
+                    &conflict.id,
+                    VectorData {
+                        vector: vec,
+                        metadata: None,
+                        created_at: unix_timestamp(),
+                        modified_at: unix_timestamp(),
+                    },
+                );
             }
         }
 
@@ -660,7 +705,10 @@ impl VersionedStore {
 
     /// List all branches
     pub fn list_branches(&self) -> Vec<Branch> {
-        self.branches.read().map(|b| b.values().cloned().collect()).unwrap_or_default()
+        self.branches
+            .read()
+            .map(|b| b.values().cloned().collect())
+            .unwrap_or_default()
     }
 
     /// List commits on current branch
@@ -696,7 +744,11 @@ impl VersionedStore {
 
     /// Get status (uncommitted changes)
     pub fn status(&self) -> StoreStatus {
-        let branch = self.current_branch.read().map(|b| b.clone()).unwrap_or_else(|_| "main".to_string());
+        let branch = self
+            .current_branch
+            .read()
+            .map(|b| b.clone())
+            .unwrap_or_else(|_| "main".to_string());
         let Ok(storages) = self.storages.read() else {
             return StoreStatus {
                 branch,
@@ -734,7 +786,9 @@ impl VersionedStore {
             return Vec::new();
         };
 
-        let mut results: Vec<_> = storage.all_ids().into_iter()
+        let mut results: Vec<_> = storage
+            .all_ids()
+            .into_iter()
             .filter_map(|id| {
                 storage.get(&id).map(|data| {
                     let score = cosine_similarity(query, &data.vector);
@@ -746,7 +800,8 @@ impl VersionedStore {
         results.sort_by(|a, b| b.1.total_cmp(&a.1));
         results.truncate(top_k);
 
-        results.into_iter()
+        results
+            .into_iter()
             .map(|(id, score)| SearchResult { id, score })
             .collect()
     }
@@ -799,7 +854,9 @@ mod tests {
     fn test_basic_operations() {
         let store = VersionedStore::new(4).unwrap();
 
-        store.upsert("doc1", vec![1.0, 0.0, 0.0, 0.0], None).unwrap();
+        store
+            .upsert("doc1", vec![1.0, 0.0, 0.0, 0.0], None)
+            .unwrap();
         let commit = store.commit("Add doc1").unwrap();
 
         assert!(!commit.hash.is_empty());
diff --git a/tests/agent_tests.rs b/tests/agent_tests.rs
index 5e85793..2cfa0de 100644
--- a/tests/agent_tests.rs
+++ b/tests/agent_tests.rs
@@ -64,7 +64,7 @@ fn test_agent_styles() {
             AgentStyle::Balanced
             | AgentStyle::Fast
             | AgentStyle::Thorough
-            | AgentStyle::Explainable => {}
+            | AgentStyle::Explainable => {},
         }
     }
 }
@@ -601,7 +601,7 @@ fn test_intent_actions() {
             | IntentAction::Compare
             | IntentAction::Explain
             | IntentAction::Transform
-            | IntentAction::Combine => {}
+            | IntentAction::Combine => {},
         }
     }
 }
diff --git a/tests/batch_operations.rs b/tests/batch_operations.rs
index 175d7a1..6869923 100644
--- a/tests/batch_operations.rs
+++ b/tests/batch_operations.rs
@@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use vecstore::{make_record, Metadata, Query, VecStore};
+use vecstore::{Metadata, Query, VecStore, make_record};
 
 #[test]
 fn test_batch_upsert_basic() {
diff --git a/tests/cross_encoder_reranking.rs b/tests/cross_encoder_reranking.rs
index 929591b..f92494a 100644
--- a/tests/cross_encoder_reranking.rs
+++ b/tests/cross_encoder_reranking.rs
@@ -6,10 +6,10 @@
 #[cfg(feature = "embeddings")]
 mod cross_encoder_tests {
     use std::collections::HashMap;
-    use vecstore::reranking::cross_encoder::{CrossEncoderModel, CrossEncoderReranker};
+    use vecstore::Metadata;
     use vecstore::reranking::Reranker;
+    use vecstore::reranking::cross_encoder::{CrossEncoderModel, CrossEncoderReranker};
     use vecstore::store::Neighbor;
-    use vecstore::Metadata;
 
     fn make_neighbor(id: &str, score: f32, text: &str) -> Neighbor {
         let mut metadata = Metadata {
@@ -67,7 +67,7 @@ mod cross_encoder_tests {
         match result {
             Ok(_) => {
                 // Model was already downloaded, which is fine
-            }
+            },
             Err(e) => {
                 // Model not downloaded, error should contain helpful message
                 let err_msg = e.to_string();
@@ -76,7 +76,7 @@ mod cross_encoder_tests {
                         || err_msg.contains("not found")
                         || err_msg.contains("huggingface.co")
                 );
-            }
+            },
         }
     }
 
diff --git a/tests/distributed_tests.rs b/tests/distributed_tests.rs
index 12b10ca..32d2efa 100644
--- a/tests/distributed_tests.rs
+++ b/tests/distributed_tests.rs
@@ -33,7 +33,10 @@ fn test_distributed_config_builder() {
     assert_eq!(config.replication_factor, 5);
     assert_eq!(config.sharding_strategy, ShardingStrategy::ConsistentHash);
     assert_eq!(config.consistency_level, ConsistencyLevel::Quorum);
-    assert_eq!(config.replication_strategy, ReplicationStrategy::PrimaryBackup);
+    assert_eq!(
+        config.replication_strategy,
+        ReplicationStrategy::PrimaryBackup
+    );
 }
 
 /// Test sharding strategies
@@ -197,11 +200,11 @@ fn test_node_status() {
     // Just ensure all statuses are valid and can be used
     for status in statuses {
         match status {
-            NodeStatus::Healthy => {}
-            NodeStatus::Degraded => {}
-            NodeStatus::Failed => {}
-            NodeStatus::Joining => {}
-            NodeStatus::Leaving => {}
+            NodeStatus::Healthy => {},
+            NodeStatus::Degraded => {},
+            NodeStatus::Failed => {},
+            NodeStatus::Joining => {},
+            NodeStatus::Leaving => {},
         }
     }
 }
diff --git a/tests/error_handling.rs b/tests/error_handling.rs
index 7d8d711..b6f9b36 100644
--- a/tests/error_handling.rs
+++ b/tests/error_handling.rs
@@ -18,10 +18,12 @@ fn test_dimension_mismatch_on_insert() {
     // Wrong dimension should fail
     let result = store.upsert("vec2".into(), vec![1.0, 0.0], meta);
     assert!(result.is_err());
-    assert!(result
-        .unwrap_err()
-        .to_string()
-        .contains("dimension mismatch"));
+    assert!(
+        result
+            .unwrap_err()
+            .to_string()
+            .contains("dimension mismatch")
+    );
 }
 
 #[test]
@@ -45,10 +47,12 @@ fn test_dimension_mismatch_on_query() {
 
     let result = store.query(query);
     assert!(result.is_err());
-    assert!(result
-        .unwrap_err()
-        .to_string()
-        .contains("dimension mismatch"));
+    assert!(
+        result
+            .unwrap_err()
+            .to_string()
+            .contains("dimension mismatch")
+    );
 }
 
 #[test]
diff --git a/tests/gpu_tests.rs b/tests/gpu_tests.rs
index cc55c8c..7c987b2 100644
--- a/tests/gpu_tests.rs
+++ b/tests/gpu_tests.rs
@@ -216,9 +216,7 @@ fn test_high_dimensional_vectors() {
     let query: Vec<f32> = (0..dim).map(|i| (i as f32) / (dim as f32)).collect();
     let database = vec![
         query.clone(),
-        (0..dim)
-            .map(|i| (i as f32) / (dim as f32) + 0.1)
-            .collect(),
+        (0..dim).map(|i| (i as f32) / (dim as f32) + 0.1).collect(),
     ];
 
     let distances = backend.batch_euclidean_distance(&query, &database).unwrap();
@@ -326,7 +324,7 @@ fn test_gpu_backend_variants() {
 
     for backend in backends {
         match backend {
-            GpuBackend::Cpu | GpuBackend::Cuda | GpuBackend::Metal | GpuBackend::WebGpu => {}
+            GpuBackend::Cpu | GpuBackend::Cuda | GpuBackend::Metal | GpuBackend::WebGpu => {},
         }
     }
 }
diff --git a/tests/openai_concurrency_tests.rs b/tests/openai_concurrency_tests.rs
index 7e7191b..1f39f68 100644
--- a/tests/openai_concurrency_tests.rs
+++ b/tests/openai_concurrency_tests.rs
@@ -251,21 +251,21 @@ async fn test_concurrent_mixed_operations() {
                 0 => {
                     // Cost estimation
                     embedder_clone.estimate_cost(&["test"])
-                }
+                },
                 1 => {
                     // Model property access
                     let _ = embedder_clone.model().dimension();
                     0.0
-                }
+                },
                 2 => {
                     // Batch cost estimation
                     let texts = vec!["a", "b", "c"];
                     embedder_clone.estimate_cost(&texts)
-                }
+                },
                 _ => {
                     // Model cost access
                     embedder_clone.model().cost_per_million_tokens()
-                }
+                },
             }
         });
         handles.push(handle);
diff --git a/tests/openai_embeddings.rs b/tests/openai_embeddings.rs
index 74c3d57..8d9e17b 100644
--- a/tests/openai_embeddings.rs
+++ b/tests/openai_embeddings.rs
@@ -7,8 +7,8 @@
 
 #[cfg(feature = "openai-embeddings")]
 mod openai_tests {
-    use vecstore::embeddings::openai_backend::{OpenAIEmbedding, OpenAIModel};
     use vecstore::embeddings::TextEmbedder;
+    use vecstore::embeddings::openai_backend::{OpenAIEmbedding, OpenAIModel};
 
     #[test]
     fn test_model_properties() {
@@ -247,7 +247,7 @@ mod openai_tests {
             Err(_) => {
                 println!("Skipping test: OPENAI_API_KEY not set");
                 return;
-            }
+            },
         };
 
         let embedder = OpenAIEmbedding::new(api_key, OpenAIModel::TextEmbedding3Small)
@@ -274,7 +274,7 @@ mod openai_tests {
             Err(_) => {
                 println!("Skipping test: OPENAI_API_KEY not set");
                 return;
-            }
+            },
         };
 
         let embedder = OpenAIEmbedding::new(api_key, OpenAIModel::TextEmbedding3Small)
@@ -305,7 +305,7 @@ mod openai_tests {
             Err(_) => {
                 println!("Skipping test: OPENAI_API_KEY not set");
                 return;
-            }
+            },
         };
 
         let embedder = OpenAIEmbedding::new(api_key, OpenAIModel::TextEmbedding3Large)
diff --git a/tests/openai_embeddings_extended.rs b/tests/openai_embeddings_extended.rs
index 6aa8b27..0cf52f0 100644
--- a/tests/openai_embeddings_extended.rs
+++ b/tests/openai_embeddings_extended.rs
@@ -7,8 +7,8 @@
 
 #[cfg(feature = "openai-embeddings")]
 mod extended_tests {
-    use vecstore::embeddings::openai_backend::{OpenAIEmbedding, OpenAIModel};
     use vecstore::embeddings::TextEmbedder;
+    use vecstore::embeddings::openai_backend::{OpenAIEmbedding, OpenAIModel};
 
     // ========================================================================
     // Empty Input Edge Cases
diff --git a/tests/openai_http_mocking.rs b/tests/openai_http_mocking.rs
index 863cd5f..d0ee89e 100644
--- a/tests/openai_http_mocking.rs
+++ b/tests/openai_http_mocking.rs
@@ -38,17 +38,26 @@ async fn test_successful_single_embedding() {
         .await;
 
     // Create embedder with mock server URL
-    let embedder = OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
-        .await
-        .expect("Failed to create embedder")
-        .with_base_url(mock_server.uri());
+    let embedder =
+        OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
+            .await
+            .expect("Failed to create embedder")
+            .with_base_url(mock_server.uri());
 
     // Test actual embedding call
     let result = embedder.embed_async("Hello world").await;
-    assert!(result.is_ok(), "Embedding should succeed: {:?}", result.err());
+    assert!(
+        result.is_ok(),
+        "Embedding should succeed: {:?}",
+        result.err()
+    );
 
     let embedding = result.unwrap();
-    assert_eq!(embedding.len(), 1536, "Embedding should have 1536 dimensions");
+    assert_eq!(
+        embedding.len(),
+        1536,
+        "Embedding should have 1536 dimensions"
+    );
 }
 
 #[tokio::test]
@@ -87,17 +96,26 @@ async fn test_rate_limit_error_with_retry() {
         .await;
 
     // Create embedder with mock server URL
-    let embedder = OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
-        .await
-        .expect("Failed to create embedder")
-        .with_base_url(mock_server.uri());
+    let embedder =
+        OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
+            .await
+            .expect("Failed to create embedder")
+            .with_base_url(mock_server.uri());
 
     // Test that retry succeeds after rate limit
     let result = embedder.embed_async("Hello world").await;
-    assert!(result.is_ok(), "Should succeed after retry: {:?}", result.err());
+    assert!(
+        result.is_ok(),
+        "Should succeed after retry: {:?}",
+        result.err()
+    );
 
     let embedding = result.unwrap();
-    assert_eq!(embedding.len(), 1536, "Embedding should have 1536 dimensions");
+    assert_eq!(
+        embedding.len(),
+        1536,
+        "Embedding should have 1536 dimensions"
+    );
 }
 
 #[tokio::test]
@@ -117,10 +135,11 @@ async fn test_authentication_error() {
         .await;
 
     // Create embedder with mock server URL
-    let embedder = OpenAIEmbedding::new("invalid-key".to_string(), OpenAIModel::TextEmbedding3Small)
-        .await
-        .expect("Failed to create embedder")
-        .with_base_url(mock_server.uri());
+    let embedder =
+        OpenAIEmbedding::new("invalid-key".to_string(), OpenAIModel::TextEmbedding3Small)
+            .await
+            .expect("Failed to create embedder")
+            .with_base_url(mock_server.uri());
 
     // Test that authentication error is properly handled
     let result = embedder.embed_async("Hello world").await;
@@ -128,7 +147,9 @@ async fn test_authentication_error() {
 
     let error = result.err().unwrap();
     assert!(
-        error.to_string().contains("401") || error.to_string().contains("Unauthorized") || error.to_string().contains("API"),
+        error.to_string().contains("401")
+            || error.to_string().contains("Unauthorized")
+            || error.to_string().contains("API"),
         "Error should indicate authentication failure: {}",
         error
     );
@@ -151,10 +172,11 @@ async fn test_server_error() {
         .await;
 
     // Create embedder with mock server URL
-    let embedder = OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
-        .await
-        .expect("Failed to create embedder")
-        .with_base_url(mock_server.uri());
+    let embedder =
+        OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
+            .await
+            .expect("Failed to create embedder")
+            .with_base_url(mock_server.uri());
 
     // Test that server error is properly handled
     let result = embedder.embed_async("Hello world").await;
@@ -162,7 +184,9 @@ async fn test_server_error() {
 
     let error = result.err().unwrap();
     assert!(
-        error.to_string().contains("500") || error.to_string().contains("server") || error.to_string().contains("error"),
+        error.to_string().contains("500")
+            || error.to_string().contains("server")
+            || error.to_string().contains("error"),
         "Error should indicate server failure: {}",
         error
     );
@@ -182,10 +206,11 @@ async fn test_malformed_response() {
         .await;
 
     // Create embedder with mock server URL
-    let embedder = OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
-        .await
-        .expect("Failed to create embedder")
-        .with_base_url(mock_server.uri());
+    let embedder =
+        OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
+            .await
+            .expect("Failed to create embedder")
+            .with_base_url(mock_server.uri());
 
     // Test that malformed response is properly handled
     let result = embedder.embed_async("Hello world").await;
@@ -225,20 +250,29 @@ async fn test_batch_embedding_with_multiple_items() {
         .await;
 
     // Create embedder with mock server URL
-    let embedder = OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
-        .await
-        .expect("Failed to create embedder")
-        .with_base_url(mock_server.uri());
+    let embedder =
+        OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
+            .await
+            .expect("Failed to create embedder")
+            .with_base_url(mock_server.uri());
 
     // Test batch embedding with multiple items
     let texts = vec!["Hello".to_string(), "World".to_string(), "Test".to_string()];
     let result = embedder.embed_batch_async(&texts).await;
-    assert!(result.is_ok(), "Batch embedding should succeed: {:?}", result.err());
+    assert!(
+        result.is_ok(),
+        "Batch embedding should succeed: {:?}",
+        result.err()
+    );
 
     let embeddings = result.unwrap();
     assert_eq!(embeddings.len(), 3, "Should return 3 embeddings");
     for embedding in &embeddings {
-        assert_eq!(embedding.len(), 1536, "Each embedding should have 1536 dimensions");
+        assert_eq!(
+            embedding.len(),
+            1536,
+            "Each embedding should have 1536 dimensions"
+        );
     }
 }
 
@@ -249,18 +283,17 @@ async fn test_network_timeout() {
     // Mock delayed response (simulates timeout) - use 5 seconds for test
     Mock::given(method("POST"))
         .and(path("/v1/embeddings"))
-        .respond_with(
-            ResponseTemplate::new(200).set_delay(std::time::Duration::from_secs(5)),
-        )
+        .respond_with(ResponseTemplate::new(200).set_delay(std::time::Duration::from_secs(5)))
         .mount(&mock_server)
         .await;
 
     // Create embedder with mock server URL and short timeout
-    let embedder = OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
-        .await
-        .expect("Failed to create embedder")
-        .with_base_url(mock_server.uri())
-        .with_timeout(std::time::Duration::from_secs(1));
+    let embedder =
+        OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
+            .await
+            .expect("Failed to create embedder")
+            .with_base_url(mock_server.uri())
+            .with_timeout(std::time::Duration::from_secs(1));
 
     // Test that timeout is properly handled
     let result = embedder.embed_async("Hello world").await;
@@ -268,9 +301,9 @@ async fn test_network_timeout() {
 
     let error = result.err().unwrap();
     assert!(
-        error.to_string().to_lowercase().contains("timeout") ||
-        error.to_string().to_lowercase().contains("timed out") ||
-        error.to_string().to_lowercase().contains("deadline"),
+        error.to_string().to_lowercase().contains("timeout")
+            || error.to_string().to_lowercase().contains("timed out")
+            || error.to_string().to_lowercase().contains("deadline"),
         "Error should indicate timeout: {}",
         error
     );
@@ -307,17 +340,26 @@ async fn test_retry_on_network_error() {
         .await;
 
     // Create embedder with mock server URL
-    let embedder = OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
-        .await
-        .expect("Failed to create embedder")
-        .with_base_url(mock_server.uri());
+    let embedder =
+        OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
+            .await
+            .expect("Failed to create embedder")
+            .with_base_url(mock_server.uri());
 
     // Test that retry succeeds after failures
     let result = embedder.embed_async("Hello world").await;
-    assert!(result.is_ok(), "Should succeed after retries: {:?}", result.err());
+    assert!(
+        result.is_ok(),
+        "Should succeed after retries: {:?}",
+        result.err()
+    );
 
     let embedding = result.unwrap();
-    assert_eq!(embedding.len(), 1536, "Embedding should have 1536 dimensions");
+    assert_eq!(
+        embedding.len(),
+        1536,
+        "Embedding should have 1536 dimensions"
+    );
 }
 
 #[tokio::test]
@@ -353,15 +395,24 @@ async fn test_embedding_order_preservation() {
         .await;
 
     // Create embedder with mock server URL
-    let embedder = OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
-        .await
-        .expect("Failed to create embedder")
-        .with_base_url(mock_server.uri());
+    let embedder =
+        OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
+            .await
+            .expect("Failed to create embedder")
+            .with_base_url(mock_server.uri());
 
     // Test batch embedding with out-of-order response
-    let texts = vec!["First".to_string(), "Second".to_string(), "Third".to_string()];
+    let texts = vec![
+        "First".to_string(),
+        "Second".to_string(),
+        "Third".to_string(),
+    ];
     let result = embedder.embed_batch_async(&texts).await;
-    assert!(result.is_ok(), "Batch embedding should succeed: {:?}", result.err());
+    assert!(
+        result.is_ok(),
+        "Batch embedding should succeed: {:?}",
+        result.err()
+    );
 
     let embeddings = result.unwrap();
     assert_eq!(embeddings.len(), 3, "Should return 3 embeddings");
@@ -369,9 +420,18 @@ async fn test_embedding_order_preservation() {
     // Verify order is preserved (first embedding should be 0.1, second 0.2, third 0.3)
     // The mock returns out-of-order (index 2 first, then 0, then 1)
     // but the embedder should reorder them correctly
-    assert!((embeddings[0][0] - 0.1).abs() < 0.001, "First embedding should be 0.1");
-    assert!((embeddings[1][0] - 0.2).abs() < 0.001, "Second embedding should be 0.2");
-    assert!((embeddings[2][0] - 0.3).abs() < 0.001, "Third embedding should be 0.3");
+    assert!(
+        (embeddings[0][0] - 0.1).abs() < 0.001,
+        "First embedding should be 0.1"
+    );
+    assert!(
+        (embeddings[1][0] - 0.2).abs() < 0.001,
+        "Second embedding should be 0.2"
+    );
+    assert!(
+        (embeddings[2][0] - 0.3).abs() < 0.001,
+        "Third embedding should be 0.3"
+    );
 }
 
 #[tokio::test]
@@ -395,15 +455,24 @@ async fn test_different_model_requests() {
         .mount(&mock_server_small)
         .await;
 
-    let embedder_small = OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
-        .await
-        .expect("Failed to create small embedder")
-        .with_base_url(mock_server_small.uri());
+    let embedder_small =
+        OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Small)
+            .await
+            .expect("Failed to create small embedder")
+            .with_base_url(mock_server_small.uri());
 
     let result_small = embedder_small.embed_async("test").await;
-    assert!(result_small.is_ok(), "Small model should succeed: {:?}", result_small.err());
+    assert!(
+        result_small.is_ok(),
+        "Small model should succeed: {:?}",
+        result_small.err()
+    );
     let embedding_small = result_small.unwrap();
-    assert_eq!(embedding_small.len(), 1536, "Small model should return 1536 dimensions");
+    assert_eq!(
+        embedding_small.len(),
+        1536,
+        "Small model should return 1536 dimensions"
+    );
 
     // Test text-embedding-3-large model
     let mock_server_large = MockServer::start().await;
@@ -424,15 +493,24 @@ async fn test_different_model_requests() {
         .mount(&mock_server_large)
         .await;
 
-    let embedder_large = OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Large)
-        .await
-        .expect("Failed to create large embedder")
-        .with_base_url(mock_server_large.uri());
+    let embedder_large =
+        OpenAIEmbedding::new("test-api-key".to_string(), OpenAIModel::TextEmbedding3Large)
+            .await
+            .expect("Failed to create large embedder")
+            .with_base_url(mock_server_large.uri());
 
     let result_large = embedder_large.embed_async("test").await;
-    assert!(result_large.is_ok(), "Large model should succeed: {:?}", result_large.err());
+    assert!(
+        result_large.is_ok(),
+        "Large model should succeed: {:?}",
+        result_large.err()
+    );
     let embedding_large = result_large.unwrap();
-    assert_eq!(embedding_large.len(), 3072, "Large model should return 3072 dimensions");
+    assert_eq!(
+        embedding_large.len(),
+        3072,
+        "Large model should return 3072 dimensions"
+    );
 }
 
 // NOTE: These tests use wiremock to simulate OpenAI API responses.
diff --git a/tests/review_regressions.rs b/tests/review_regressions.rs
index fac2fc5..da426c1 100644
--- a/tests/review_regressions.rs
+++ b/tests/review_regressions.rs
@@ -4,9 +4,9 @@ use std::panic::{self, AssertUnwindSafe};
 use tempfile::tempdir;
 use vecstore::store::hybrid::{HybridQuery, TextIndex};
 use vecstore::{
+    Distance, HNSWSearchParams, Metadata, NamespaceManager, NamespaceStatus, Query, VecStore,
     distributed::{DistributedConfig, DistributedStore},
-    parse_filter, Distance, HNSWSearchParams, Metadata, NamespaceManager, NamespaceStatus, Query,
-    VecStore,
+    parse_filter,
 };
 
 fn empty_metadata() -> Metadata {
@@ -468,7 +468,8 @@ fn query_with_filter_should_not_silently_ignore_parse_errors() {
     assert!(
         results
             .iter()
-            .all(|neighbor| neighbor.metadata.fields.get("role") == Some(&serde_json::json!("admin"))),
+            .all(|neighbor| neighbor.metadata.fields.get("role")
+                == Some(&serde_json::json!("admin"))),
         "Invalid filter syntax should not be silently ignored; expected only admin results, got {:?}",
         results
     );
diff --git a/tests/selectivity_tests.rs b/tests/selectivity_tests.rs
index 3074c54..060a0b9 100644
--- a/tests/selectivity_tests.rs
+++ b/tests/selectivity_tests.rs
@@ -26,7 +26,7 @@ fn test_eq_selectivity() {
             assert_eq!(field, "category");
             assert_eq!(*op, FilterOp::Eq);
             assert_eq!(*value, json!("electronics"));
-        }
+        },
         _ => panic!("Expected Cmp filter"),
     }
 }
@@ -39,7 +39,7 @@ fn test_neq_selectivity() {
     match &filter {
         FilterExpr::Cmp { op, .. } => {
             assert_eq!(*op, FilterOp::Neq);
-        }
+        },
         _ => panic!("Expected Cmp filter"),
     }
 }
@@ -87,7 +87,7 @@ fn test_and_selectivity() {
     match &filter {
         FilterExpr::And(exprs) => {
             assert_eq!(exprs.len(), 2);
-        }
+        },
         _ => panic!("Expected And filter"),
     }
 }
@@ -103,7 +103,7 @@ fn test_or_selectivity() {
     match &filter {
         FilterExpr::Or(exprs) => {
             assert_eq!(exprs.len(), 2);
-        }
+        },
         _ => panic!("Expected Or filter"),
     }
 }
@@ -114,12 +114,10 @@ fn test_not_selectivity() {
     let filter = FilterExpr::Not(Box::new(cmp("status", FilterOp::Eq, json!("archived"))));
 
     match &filter {
-        FilterExpr::Not(inner) => {
-            match inner.as_ref() {
-                FilterExpr::Cmp { op, .. } => assert_eq!(*op, FilterOp::Eq),
-                _ => panic!("Expected inner Cmp filter"),
-            }
-        }
+        FilterExpr::Not(inner) => match inner.as_ref() {
+            FilterExpr::Cmp { op, .. } => assert_eq!(*op, FilterOp::Eq),
+            _ => panic!("Expected inner Cmp filter"),
+        },
         _ => panic!("Expected Not filter"),
     }
 }
@@ -144,7 +142,7 @@ fn test_in_filter() {
         FilterExpr::Cmp { op, value, .. } => {
             assert_eq!(*op, FilterOp::In);
             assert!(value.is_array());
-        }
+        },
         _ => panic!("Expected Cmp filter"),
     }
 }
@@ -158,7 +156,7 @@ fn test_not_in_filter() {
         FilterExpr::Cmp { op, value, .. } => {
             assert_eq!(*op, FilterOp::NotIn);
             assert!(value.is_array());
-        }
+        },
         _ => panic!("Expected Cmp filter"),
     }
 }
@@ -196,11 +194,11 @@ fn test_complex_nested_filter() {
                 match branch {
                     FilterExpr::And(conditions) => {
                         assert_eq!(conditions.len(), 2);
-                    }
+                    },
                     _ => panic!("Expected And filter in branch"),
                 }
             }
-        }
+        },
         _ => panic!("Expected Or filter"),
     }
 }
@@ -220,13 +218,13 @@ fn test_deeply_nested_not() {
             match inner.as_ref() {
                 FilterExpr::Not(innermost) => {
                     match innermost.as_ref() {
-                        FilterExpr::Cmp { .. } => {} // Expected
+                        FilterExpr::Cmp { .. } => {}, // Expected
                         _ => panic!("Expected innermost Cmp"),
                     }
-                }
+                },
                 _ => panic!("Expected inner Not"),
             }
-        }
+        },
         _ => panic!("Expected outer Not"),
     }
 }
@@ -239,7 +237,7 @@ fn test_empty_and() {
     match &filter {
         FilterExpr::And(exprs) => {
             assert!(exprs.is_empty());
-        }
+        },
         _ => panic!("Expected And filter"),
     }
 }
@@ -252,7 +250,7 @@ fn test_empty_or() {
     match &filter {
         FilterExpr::Or(exprs) => {
             assert!(exprs.is_empty());
-        }
+        },
         _ => panic!("Expected Or filter"),
     }
 }
@@ -303,7 +301,7 @@ fn test_filter_serialization() {
     match deserialized {
         FilterExpr::And(exprs) => {
             assert_eq!(exprs.len(), 2);
-        }
+        },
         _ => panic!("Expected And filter after deserialization"),
     }
 }
diff --git a/tests/test_final_optimizations.rs b/tests/test_final_optimizations.rs
index d248ab8..fed202e 100644
--- a/tests/test_final_optimizations.rs
+++ b/tests/test_final_optimizations.rs
@@ -258,10 +258,12 @@ fn test_prefetch_empty_stages() {
 
     let result = store.prefetch_query(prefetch_query);
     assert!(result.is_err());
-    assert!(result
-        .unwrap_err()
-        .to_string()
-        .contains("at least one stage"));
+    assert!(
+        result
+            .unwrap_err()
+            .to_string()
+            .contains("at least one stage")
+    );
 }
 
 #[test]
@@ -276,10 +278,12 @@ fn test_prefetch_mmr_without_previous_stage() {
 
     let result = store.prefetch_query(prefetch_query);
     assert!(result.is_err());
-    assert!(result
-        .unwrap_err()
-        .to_string()
-        .contains("requires previous stage"));
+    assert!(
+        result
+            .unwrap_err()
+            .to_string()
+            .contains("requires previous stage")
+    );
 }
 
 #[test]
diff --git a/tests/wal_tests.rs b/tests/wal_tests.rs
index 47d71df..d4594f8 100644
--- a/tests/wal_tests.rs
+++ b/tests/wal_tests.rs
@@ -97,7 +97,7 @@ fn test_wal_replay_single_entry() {
         LogEntry::Insert { id, vector } => {
             assert_eq!(id, "doc1");
             assert_eq!(vector, &vec![1.0, 2.0, 3.0]);
-        }
+        },
         _ => panic!("Expected Insert entry"),
     }
 }
@@ -283,7 +283,7 @@ fn test_wal_durability_after_crash() {
             LogEntry::Insert { id, vector } => {
                 assert_eq!(id, &format!("doc{}", i));
                 assert_eq!(vector, &vec![i as f32, (i * 2) as f32]);
-            }
+            },
             _ => panic!("Expected Insert entry"),
         }
     }
@@ -309,7 +309,7 @@ fn test_wal_large_vectors() {
         LogEntry::Insert { vector, .. } => {
             assert_eq!(vector.len(), 1536);
             assert_eq!(vector, &large_vector);
-        }
+        },
         _ => panic!("Expected Insert entry"),
     }
 }
@@ -341,7 +341,7 @@ fn test_wal_sequence_ordering() {
             LogEntry::Insert { id, vector } => {
                 assert_eq!(id, &format!("doc{:03}", i));
                 assert_eq!(vector, &vec![i as f32]);
-            }
+            },
             _ => panic!("Expected Insert entry"),
         }
     }
@@ -488,8 +488,8 @@ fn test_wal_checkpoint_marker() {
             match &entries[0] {
                 LogEntry::Checkpoint { sequence } => {
                     assert_eq!(*sequence, 100);
-                }
-                _ => {} // Other entry types are also valid
+                },
+                _ => {}, // Other entry types are also valid
             }
         }
     }