diff --git a/.clang-tidy b/.clang-tidy
index 5b99fe0bf..a7f55d31c 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -33,12 +33,13 @@ Checks: >
     -readability-identifier-length,
     -readability-magic-numbers,
     -readability-function-cognitive-complexity, # enable after fix all
-    -readability-redundant-access-specifiers
+    -readability-redundant-access-specifiers,
+    -readability-avoid-nested-conditional-operator
 
 
 HeaderFilterRegex: ''
 WarningsAsErrors: "*"
-AnalyzeTemporaryDtors: true
+# AnalyzeTemporaryDtors: true
 
 CheckOptions:
   - { key: readability-identifier-naming.NamespaceCase,               value: lower_case }
diff --git a/src/algorithm/brute_force.h b/src/algorithm/brute_force.h
index 408467152..918ec33c7 100644
--- a/src/algorithm/brute_force.h
+++ b/src/algorithm/brute_force.h
@@ -36,7 +36,7 @@ class BruteForce : public InnerIndexInterface {
     explicit BruteForce(const BruteForceParameterPtr& param, const IndexCommonParam& common_param);
 
     explicit BruteForce(const ParamPtr& param, const IndexCommonParam& common_param)
-        : BruteForce(std::dynamic_pointer_cast<BruteForceParameter>(param), common_param){};
+        : BruteForce(std::dynamic_pointer_cast<BruteForceParameter>(param), common_param) {};
 
     ~BruteForce() override = default;
 
diff --git a/src/algorithm/hgraph.cpp b/src/algorithm/hgraph.cpp
index 553aa9044..84332fab1 100644
--- a/src/algorithm/hgraph.cpp
+++ b/src/algorithm/hgraph.cpp
@@ -165,7 +165,7 @@ HGraph::build_by_odescent(const DatasetPtr& data) {
         if (level >= 0) {
             if (level >= static_cast<int>(route_graph_ids.size()) || route_graph_ids.empty()) {
                 for (auto k = static_cast<int>(route_graph_ids.size()); k <= level; ++k) {
-                    route_graph_ids.emplace_back(Vector<InnerIdType>(allocator_));
+                    route_graph_ids.emplace_back(allocator_);
                 }
                 entry_point_id_ = inner_id;
             }
diff --git a/src/algorithm/hgraph.h b/src/algorithm/hgraph.h
index 821a8a0d4..2f870e301 100644
--- a/src/algorithm/hgraph.h
+++ b/src/algorithm/hgraph.h
@@ -56,7 +56,7 @@ class HGraph : public InnerIndexInterface {
     HGraph(const HGraphParameterPtr& param, const IndexCommonParam& common_param);
 
     HGraph(const ParamPtr& param, const IndexCommonParam& common_param)
-        : HGraph(std::dynamic_pointer_cast<HGraphParameter>(param), common_param){};
+        : HGraph(std::dynamic_pointer_cast<HGraphParameter>(param), common_param) {};
 
     ~HGraph() override = default;
 
diff --git a/src/algorithm/hnswlib/.clang-tidy b/src/algorithm/hnswlib/.clang-tidy
index d75711fcb..f1e234e5f 100644
--- a/src/algorithm/hnswlib/.clang-tidy
+++ b/src/algorithm/hnswlib/.clang-tidy
@@ -22,7 +22,7 @@ Checks: >
 
 HeaderFilterRegex: ''
 WarningsAsErrors: "*"
-AnalyzeTemporaryDtors: true
+# AnalyzeTemporaryDtors: true
 
 CheckOptions:
   - { key: readability-identifier-naming.NamespaceCase,               value: lower_case }
diff --git a/src/algorithm/inner_index_interface.h b/src/algorithm/inner_index_interface.h
index 0586d9e96..14a4d189d 100644
--- a/src/algorithm/inner_index_interface.h
+++ b/src/algorithm/inner_index_interface.h
@@ -94,7 +94,7 @@ class InnerIndexInterface {
 
 public:
     virtual void
-    Train(const DatasetPtr& base){};
+    Train(const DatasetPtr& base) {};
 
     virtual std::vector<int64_t>
     Build(const DatasetPtr& base);
diff --git a/src/algorithm/ivf.cpp b/src/algorithm/ivf.cpp
index 949e12525..1f8a48f20 100644
--- a/src/algorithm/ivf.cpp
+++ b/src/algorithm/ivf.cpp
@@ -939,8 +939,7 @@ IVF::fill_location_map() {
             if (ids[j] >= this->total_elements_ * buckets_per_data_) {
                 throw VsagException(ErrorType::INTERNAL_ERROR, "invalid inner_id");
             }
-            this->location_map_[ids[j]] =
-                (static_cast<uint64_t>(i) << LOCATION_SPLIT_BIT) | static_cast<uint64_t>(j);
+            this->location_map_[ids[j]] = (static_cast<uint64_t>(i) << LOCATION_SPLIT_BIT) | j;
         }
     }
 }
diff --git a/src/algorithm/ivf.h b/src/algorithm/ivf.h
index 027545497..cf4d981d2 100644
--- a/src/algorithm/ivf.h
+++ b/src/algorithm/ivf.h
@@ -42,7 +42,7 @@ class IVF : public InnerIndexInterface {
     explicit IVF(const IVFParameterPtr& param, const IndexCommonParam& common_param);
 
     explicit IVF(const ParamPtr& param, const IndexCommonParam& common_param)
-        : IVF(std::dynamic_pointer_cast<IVFParameter>(param), common_param){};
+        : IVF(std::dynamic_pointer_cast<IVFParameter>(param), common_param) {};
 
     ~IVF() override = default;
 
diff --git a/src/algorithm/ivf_parameter.cpp b/src/algorithm/ivf_parameter.cpp
index 9ada0a9f8..ffba09993 100644
--- a/src/algorithm/ivf_parameter.cpp
+++ b/src/algorithm/ivf_parameter.cpp
@@ -37,9 +37,9 @@ IVFParameter::FromJson(const JsonType& json) {
 
     if (this->ivf_partition_strategy_parameter->partition_strategy_type ==
         IVFPartitionStrategyType::GNO_IMI) {
-        this->bucket_param->buckets_count = static_cast<BucketIdType>(
+        this->bucket_param->buckets_count = (static_cast<int64_t>(
             this->ivf_partition_strategy_parameter->gnoimi_param->first_order_buckets_count *
-            this->ivf_partition_strategy_parameter->gnoimi_param->second_order_buckets_count);
+            this->ivf_partition_strategy_parameter->gnoimi_param->second_order_buckets_count));
     }
 
     if (json.contains(BUCKET_PER_DATA_KEY)) {
diff --git a/src/algorithm/ivf_partition/ivf_partition_strategy.h b/src/algorithm/ivf_partition/ivf_partition_strategy.h
index 54c21f04d..e7772fdeb 100644
--- a/src/algorithm/ivf_partition/ivf_partition_strategy.h
+++ b/src/algorithm/ivf_partition/ivf_partition_strategy.h
@@ -49,7 +49,7 @@ class IVFPartitionStrategy {
           thread_pool_(common_param.thread_pool_),
           bucket_count_(bucket_count),
           dim_(common_param.dim_),
-          metric_type_(common_param.metric_){};
+          metric_type_(common_param.metric_) {};
 
     virtual void
     Train(const DatasetPtr dataset) = 0;
diff --git a/src/algorithm/pyramid.h b/src/algorithm/pyramid.h
index 7b998879f..f7d66e95e 100644
--- a/src/algorithm/pyramid.h
+++ b/src/algorithm/pyramid.h
@@ -93,7 +93,7 @@ class Pyramid : public InnerIndexInterface {
     }
 
     explicit Pyramid(const ParamPtr& param, const IndexCommonParam& common_param)
-        : Pyramid(std::dynamic_pointer_cast<PyramidParameters>(param), common_param){};
+        : Pyramid(std::dynamic_pointer_cast<PyramidParameters>(param), common_param) {};
 
     std::string
     GetName() const override {
diff --git a/src/algorithm/sindi/sindi.cpp b/src/algorithm/sindi/sindi.cpp
index 1d648959a..3a6cf8226 100644
--- a/src/algorithm/sindi/sindi.cpp
+++ b/src/algorithm/sindi/sindi.cpp
@@ -152,8 +152,8 @@ SINDI::search_impl(const SparseTermComputerPtr& computer,
     if constexpr (mode == KNN_SEARCH) {
         // fill up to k
         while (heap.size() < k) {
-            heap.push(
-                {std::numeric_limits<float>::max(), 0});  // TODO(ZXY): replace with random points
+            heap.emplace(std::numeric_limits<float>::max(),
+                         0);  // TODO(ZXY): replace with random points
         }
     }
 
diff --git a/src/algorithm/sindi/sindi.h b/src/algorithm/sindi/sindi.h
index 9bf29be0e..8630c22d3 100644
--- a/src/algorithm/sindi/sindi.h
+++ b/src/algorithm/sindi/sindi.h
@@ -30,7 +30,7 @@ class SINDI : public InnerIndexInterface {
     explicit SINDI(const SINDIParameterPtr& param, const IndexCommonParam& common_param);
 
     SINDI(const ParamPtr& param, const IndexCommonParam& common_param)
-        : SINDI(std::dynamic_pointer_cast<SINDIParameter>(param), common_param){};
+        : SINDI(std::dynamic_pointer_cast<SINDIParameter>(param), common_param) {};
 
     ~SINDI() = default;
 
diff --git a/src/algorithm/sparse_index.h b/src/algorithm/sparse_index.h
index bd70b3efc..9a7b6a3a5 100644
--- a/src/algorithm/sparse_index.h
+++ b/src/algorithm/sparse_index.h
@@ -35,7 +35,7 @@ class SparseIndex : public InnerIndexInterface {
     }
 
     SparseIndex(const ParamPtr& param, const IndexCommonParam& common_param)
-        : SparseIndex(std::dynamic_pointer_cast<SparseIndexParameters>(param), common_param){};
+        : SparseIndex(std::dynamic_pointer_cast<SparseIndexParameters>(param), common_param) {};
 
     ~SparseIndex() override {
         for (auto& data : datas_) {
diff --git a/src/attr/executor/executor.h b/src/attr/executor/executor.h
index 1f35ce285..fa67f3e04 100644
--- a/src/attr/executor/executor.h
+++ b/src/attr/executor/executor.h
@@ -36,7 +36,7 @@ class Executor {
         : expr_(expression),
           attr_index_(attr_index),
           allocator_(allocator),
-          bitset_type_(attr_index->GetBitsetType()){};
+          bitset_type_(attr_index->GetBitsetType()) {};
 
     virtual ~Executor() {
         if (this->own_bitset_) {
@@ -54,7 +54,7 @@ class Executor {
     };
 
     virtual void
-    Init(){};
+    Init() {};
 
     virtual Filter*
     Run(BucketIdType bucket_id) = 0;
diff --git a/src/attr/expression_visitor.cpp b/src/attr/expression_visitor.cpp
index 613667b04..47adeda68 100644
--- a/src/attr/expression_visitor.cpp
+++ b/src/attr/expression_visitor.cpp
@@ -117,7 +117,7 @@ string_view_split(std::string_view str, char delim) {
     result.emplace_back(str.substr(start));
     return result;
 }
-FCExpressionVisitor::FCExpressionVisitor(AttrTypeSchema* schema) : schema_(schema){};
+FCExpressionVisitor::FCExpressionVisitor(AttrTypeSchema* schema) : schema_(schema) {};
 
 std::any
 FCExpressionVisitor::visitFilter_condition(FCParser::Filter_conditionContext* ctx) {
diff --git a/src/data_cell/attribute_bucket_inverted_datacell.h b/src/data_cell/attribute_bucket_inverted_datacell.h
index 7c26ea48d..9d5f5970b 100644
--- a/src/data_cell/attribute_bucket_inverted_datacell.h
+++ b/src/data_cell/attribute_bucket_inverted_datacell.h
@@ -28,7 +28,7 @@ class AttributeBucketInvertedDataCell : public AttributeInvertedInterface {
 public:
     AttributeBucketInvertedDataCell(
         Allocator* allocator, ComputableBitsetType bitset_type = ComputableBitsetType::FastBitset)
-        : AttributeInvertedInterface(allocator, bitset_type), field_2_value_map_(allocator){};
+        : AttributeInvertedInterface(allocator, bitset_type), field_2_value_map_(allocator) {};
 
     ~AttributeBucketInvertedDataCell() override = default;
 
diff --git a/src/data_cell/attribute_inverted_interface.h b/src/data_cell/attribute_inverted_interface.h
index 69d5e6e60..80110383d 100644
--- a/src/data_cell/attribute_inverted_interface.h
+++ b/src/data_cell/attribute_inverted_interface.h
@@ -36,7 +36,7 @@ class AttributeInvertedInterface {
 
 public:
     AttributeInvertedInterface(Allocator* allocator, ComputableBitsetType bitset_type)
-        : allocator_(allocator), field_type_map_(allocator), bitset_type_(bitset_type){};
+        : allocator_(allocator), field_type_map_(allocator), bitset_type_(bitset_type) {};
 
     virtual ~AttributeInvertedInterface() = default;
 
diff --git a/src/data_cell/bucket_datacell_test.cpp b/src/data_cell/bucket_datacell_test.cpp
index 2b1f31045..82af8b43e 100644
--- a/src/data_cell/bucket_datacell_test.cpp
+++ b/src/data_cell/bucket_datacell_test.cpp
@@ -32,7 +32,7 @@ namespace vsag {
 class BucketInterfaceTest {
 public:
     BucketInterfaceTest(BucketInterfacePtr bucket, MetricType metric)
-        : bucket_(std::move(bucket)), metric_(metric){};
+        : bucket_(std::move(bucket)), metric_(metric) {};
 
     void
     BasicTest(int64_t dim, uint64_t base_count, float error = 1e-5f);
diff --git a/src/data_cell/bucket_interface.h b/src/data_cell/bucket_interface.h
index f01e8ea2c..195608407 100644
--- a/src/data_cell/bucket_interface.h
+++ b/src/data_cell/bucket_interface.h
@@ -103,10 +103,10 @@ class BucketInterface {
     }
 
     virtual void
-    Package(){};
+    Package() {};
 
     virtual void
-    Unpack(){};
+    Unpack() {};
 
 public:
     BucketIdType bucket_count_{0};
diff --git a/src/data_cell/extra_info_interface.h b/src/data_cell/extra_info_interface.h
index b9a44494e..6d2afaa63 100644
--- a/src/data_cell/extra_info_interface.h
+++ b/src/data_cell/extra_info_interface.h
@@ -102,10 +102,10 @@ class ExtraInfoInterface {
     InMemory() const = 0;
 
     virtual void
-    EnableForceInMemory(){};
+    EnableForceInMemory() {};
 
     virtual void
-    DisableForceInMemory(){};
+    DisableForceInMemory() {};
 
 public:
     InnerIdType total_count_{0};
diff --git a/src/data_cell/flatten_interface_test.h b/src/data_cell/flatten_interface_test.h
index 18bd3250b..d92882ad2 100644
--- a/src/data_cell/flatten_interface_test.h
+++ b/src/data_cell/flatten_interface_test.h
@@ -24,7 +24,7 @@ namespace vsag {
 class FlattenInterfaceTest {
 public:
     FlattenInterfaceTest(FlattenInterfacePtr flatten, MetricType metric)
-        : flatten_(flatten), metric_(metric){};
+        : flatten_(flatten), metric_(metric) {};
 
     void
     BasicTest(int64_t dim, uint64_t base_count, float error = 1e-5f);
diff --git a/src/data_cell/graph_interface_parameter.h b/src/data_cell/graph_interface_parameter.h
index c09b3242e..fda3c1a44 100644
--- a/src/data_cell/graph_interface_parameter.h
+++ b/src/data_cell/graph_interface_parameter.h
@@ -40,7 +40,7 @@ class GraphInterfaceParameter : public Parameter {
 
 protected:
     explicit GraphInterfaceParameter(GraphStorageTypes graph_type)
-        : graph_storage_type_(graph_type){};
+        : graph_storage_type_(graph_type) {};
 };
 
 }  // namespace vsag
diff --git a/src/data_cell/sparse_graph_datacell.cpp b/src/data_cell/sparse_graph_datacell.cpp
index 7fd971d9b..75f4c4d12 100644
--- a/src/data_cell/sparse_graph_datacell.cpp
+++ b/src/data_cell/sparse_graph_datacell.cpp
@@ -152,7 +152,7 @@ SparseGraphDataCell::Deserialize(StreamReader& reader) {
 }
 
 void
-SparseGraphDataCell::Resize(InnerIdType new_size){};
+SparseGraphDataCell::Resize(InnerIdType new_size) {};
 
 void
 SparseGraphDataCell::DeleteNeighborsById(vsag::InnerIdType id) {
diff --git a/src/data_cell/sparse_vector_datacell.h b/src/data_cell/sparse_vector_datacell.h
index 6f8ab4eb1..45b813efa 100644
--- a/src/data_cell/sparse_vector_datacell.h
+++ b/src/data_cell/sparse_vector_datacell.h
@@ -79,7 +79,7 @@ class SparseVectorDataCell : public FlattenInterface {
     }
 
     void
-    Prefetch(InnerIdType id) override{};
+    Prefetch(InnerIdType id) override {};
 
     void
     ExportModel(const FlattenInterfacePtr& other) const override {
diff --git a/src/impl/allocator/safe_allocator.h b/src/impl/allocator/safe_allocator.h
index 1977ed7bf..600a99b78 100644
--- a/src/impl/allocator/safe_allocator.h
+++ b/src/impl/allocator/safe_allocator.h
@@ -31,7 +31,7 @@ class SafeAllocator : public Allocator {
     }
 
 public:
-    explicit SafeAllocator(Allocator* raw_allocator) : SafeAllocator(raw_allocator, false){};
+    explicit SafeAllocator(Allocator* raw_allocator) : SafeAllocator(raw_allocator, false) {};
 
     explicit SafeAllocator(Allocator* raw_allocator, bool owned)
         : raw_allocator_(raw_allocator), owned_(owned) {
diff --git a/src/impl/basic_searcher_test.cpp b/src/impl/basic_searcher_test.cpp
index 3b916bb4d..69cbe7386 100644
--- a/src/impl/basic_searcher_test.cpp
+++ b/src/impl/basic_searcher_test.cpp
@@ -34,7 +34,7 @@ using namespace vsag;
 
 class AdaptGraphDataCell : public GraphInterface {
 public:
-    AdaptGraphDataCell(std::shared_ptr<hnswlib::HierarchicalNSW> alg_hnsw) : alg_hnsw_(alg_hnsw){};
+    AdaptGraphDataCell(std::shared_ptr<hnswlib::HierarchicalNSW> alg_hnsw) : alg_hnsw_(alg_hnsw) {};
 
     void
     InsertNeighborsById(InnerIdType id, const Vector<InnerIdType>& neighbor_ids) override {
diff --git a/src/impl/bitset/fast_bitset.h b/src/impl/bitset/fast_bitset.h
index d6abe5622..0d4e760c4 100644
--- a/src/impl/bitset/fast_bitset.h
+++ b/src/impl/bitset/fast_bitset.h
@@ -25,7 +25,7 @@ namespace vsag {
 class FastBitset : public ComputableBitset {
 public:
     explicit FastBitset(Allocator* allocator)
-        : ComputableBitset(), data_(nullptr), size_(0), capacity_(0){};
+        : ComputableBitset(), data_(nullptr), size_(0), capacity_(0) {};
 
     ~FastBitset() override {
         delete[] data_;
diff --git a/src/impl/bitset/sparse_bitset.h b/src/impl/bitset/sparse_bitset.h
index dd6c0d368..5a4b1173b 100644
--- a/src/impl/bitset/sparse_bitset.h
+++ b/src/impl/bitset/sparse_bitset.h
@@ -32,7 +32,7 @@ class SparseBitset : public ComputableBitset {
 
     ~SparseBitset() override = default;
 
-    explicit SparseBitset(Allocator* allocator) : SparseBitset(){};
+    explicit SparseBitset(Allocator* allocator) : SparseBitset() {};
 
     SparseBitset(const SparseBitset&) = delete;
     SparseBitset&
diff --git a/src/impl/filter/black_list_filter.h b/src/impl/filter/black_list_filter.h
index 70b8e2aab..1f4e774b9 100644
--- a/src/impl/filter/black_list_filter.h
+++ b/src/impl/filter/black_list_filter.h
@@ -26,12 +26,12 @@ namespace vsag {
 class BlackListFilter : public Filter {
 public:
     explicit BlackListFilter(const IdFilterFuncType& fallback_func)
-        : fallback_func_(fallback_func), is_bitset_filter_(false), bitset_(nullptr){};
+        : fallback_func_(fallback_func), is_bitset_filter_(false), bitset_(nullptr) {};
 
     explicit BlackListFilter(const BitsetPtr& bitset)
-        : bitset_(bitset.get()), is_bitset_filter_(true){};
+        : bitset_(bitset.get()), is_bitset_filter_(true) {};
 
-    explicit BlackListFilter(const Bitset* bitset) : bitset_(bitset), is_bitset_filter_(true){};
+    explicit BlackListFilter(const Bitset* bitset) : bitset_(bitset), is_bitset_filter_(true) {};
 
     bool
     CheckValid(int64_t id) const override;
diff --git a/src/impl/filter/extrainfo_wrapper_filter.h b/src/impl/filter/extrainfo_wrapper_filter.h
index cf59e8252..c2c270263 100644
--- a/src/impl/filter/extrainfo_wrapper_filter.h
+++ b/src/impl/filter/extrainfo_wrapper_filter.h
@@ -27,7 +27,7 @@ namespace vsag {
 class ExtraInfoWrapperFilter : public Filter {
 public:
     ExtraInfoWrapperFilter(const FilterPtr filter_impl, const ExtraInfoInterfacePtr& extra_infos)
-        : filter_impl_(filter_impl), extra_infos_(extra_infos){};
+        : filter_impl_(filter_impl), extra_infos_(extra_infos) {};
 
     [[nodiscard]] bool
     CheckValid(int64_t inner_id) const override;
diff --git a/src/impl/filter/inner_id_wrapper_filter.h b/src/impl/filter/inner_id_wrapper_filter.h
index f31c5ef4c..7a820ff4f 100644
--- a/src/impl/filter/inner_id_wrapper_filter.h
+++ b/src/impl/filter/inner_id_wrapper_filter.h
@@ -23,7 +23,7 @@ namespace vsag {
 class InnerIdWrapperFilter : public Filter {
 public:
     InnerIdWrapperFilter(const FilterPtr filter_impl, const LabelTable& label_table)
-        : filter_impl_(filter_impl), label_table_(label_table){};
+        : filter_impl_(filter_impl), label_table_(label_table) {};
 
     [[nodiscard]] bool
     CheckValid(int64_t inner_id) const override {
diff --git a/src/impl/filter/white_list_filter.h b/src/impl/filter/white_list_filter.h
index 98b31fd37..3136217e9 100644
--- a/src/impl/filter/white_list_filter.h
+++ b/src/impl/filter/white_list_filter.h
@@ -26,12 +26,12 @@ namespace vsag {
 class WhiteListFilter : public Filter {
 public:
     explicit WhiteListFilter(const IdFilterFuncType& fallback_func)
-        : fallback_func_(fallback_func), is_bitset_filter_(false), bitset_(nullptr){};
+        : fallback_func_(fallback_func), is_bitset_filter_(false), bitset_(nullptr) {};
 
     explicit WhiteListFilter(const BitsetPtr& bitset)
-        : bitset_(bitset.get()), is_bitset_filter_(true){};
+        : bitset_(bitset.get()), is_bitset_filter_(true) {};
 
-    explicit WhiteListFilter(const Bitset* bitset) : bitset_(bitset), is_bitset_filter_(true){};
+    explicit WhiteListFilter(const Bitset* bitset) : bitset_(bitset), is_bitset_filter_(true) {};
 
     bool
     CheckValid(int64_t id) const override;
diff --git a/src/impl/heap/distance_heap.cpp b/src/impl/heap/distance_heap.cpp
index 6e5ab1799..05416fe63 100644
--- a/src/impl/heap/distance_heap.cpp
+++ b/src/impl/heap/distance_heap.cpp
@@ -38,13 +38,13 @@ DistanceHeap::MakeInstanceBySize<false, true>(Allocator* allocator, int64_t max_
 template DistHeapPtr
 DistanceHeap::MakeInstanceBySize<false, false>(Allocator* allocator, int64_t max_size);
 
-DistanceHeap::DistanceHeap(Allocator* allocator) : DistanceHeap(allocator, -1){};
+DistanceHeap::DistanceHeap(Allocator* allocator) : DistanceHeap(allocator, -1) {};
 
 DistanceHeap::DistanceHeap(Allocator* allocator, int64_t max_size)
-    : allocator_(allocator), max_size_(max_size){};
+    : allocator_(allocator), max_size_(max_size) {};
 
 void
 DistanceHeap::Push(const DistanceRecord& record) {
-    return this->Push(record.first, record.second);
+    this->Push(record.first, record.second);
 }
 }  // namespace vsag
diff --git a/src/impl/heap/memmove_heap.cpp b/src/impl/heap/memmove_heap.cpp
index b59d57cd4..16a6ba152 100644
--- a/src/impl/heap/memmove_heap.cpp
+++ b/src/impl/heap/memmove_heap.cpp
@@ -27,7 +27,7 @@ MemmoveHeap<max_heap, fixed_size>::MemmoveHeap(Allocator* allocator, int64_t max
 template <bool max_heap, bool fixed_size>
 void
 MemmoveHeap<max_heap, fixed_size>::Push(float dist, InnerIdType id) {
-    using CompareType = typename std::conditional<max_heap, CompareMax, CompareMin>::type;
+    using CompareType = std::conditional_t<max_heap, CompareMax, CompareMin>;
     if constexpr (fixed_size) {
         if (this->Size() < max_size_ or (dist < this->Top().first) == max_heap) {
             DistanceRecord record = {dist, id};
diff --git a/src/impl/odescent_graph_builder.cpp b/src/impl/odescent_graph_builder.cpp
index 727f37e42..b3e51b60e 100644
--- a/src/impl/odescent_graph_builder.cpp
+++ b/src/impl/odescent_graph_builder.cpp
@@ -37,7 +37,7 @@ ODescent::Build(const Vector<InnerIdType>& ids_sequence, const GraphInterfacePtr
                             "ODescent cannot build a graph with data_num less than 0");
     }
     if (data_num_ == 1) {
-        graph_.push_back(Linklist(allocator_));
+        graph_.emplace_back(allocator_);
         return true;
     }
     Vector<std::mutex>(data_num_, allocator_).swap(points_lock_);
diff --git a/src/impl/transform/random_orthogonal_transformer.cpp b/src/impl/transform/random_orthogonal_transformer.cpp
index bfe756db0..1142b8c65 100644
--- a/src/impl/transform/random_orthogonal_transformer.cpp
+++ b/src/impl/transform/random_orthogonal_transformer.cpp
@@ -64,11 +64,11 @@ RandomOrthogonalMatrix::Transform(const float* original_vec, float* transformed_
     auto dim = static_cast<blasint>(this->input_dim_);
     cblas_sgemv(CblasRowMajor,
                 CblasNoTrans,
-                static_cast<blasint>(dim),
-                static_cast<blasint>(dim),
+                dim,
+                dim,
                 1.0F,
                 orthogonal_matrix_.data(),
-                static_cast<blasint>(dim),
+                dim,
                 original_vec,
                 1,
                 0.0F,
@@ -84,11 +84,11 @@ RandomOrthogonalMatrix::InverseTransform(const float* transformed_vec, float* or
     auto dim = static_cast<blasint>(this->input_dim_);
     cblas_sgemv(CblasRowMajor,
                 CblasTrans,
-                static_cast<blasint>(dim),
-                static_cast<blasint>(dim),
+                dim,
+                dim,
                 1.0F,
                 orthogonal_matrix_.data(),
-                static_cast<blasint>(dim),
+                dim,
                 transformed_vec,
                 1,
                 0.0F,
diff --git a/src/impl/transform/vector_transformer.h b/src/impl/transform/vector_transformer.h
index a54d5c3a1..f4d02268c 100644
--- a/src/impl/transform/vector_transformer.h
+++ b/src/impl/transform/vector_transformer.h
@@ -84,7 +84,7 @@ class VectorTransformer {
 
 public:
     virtual void
-    Train(const float* data, uint64_t count){};
+    Train(const float* data, uint64_t count) {};
 
     virtual void
     InverseTransform(const float* input_vec, float* output_vec) const;
diff --git a/src/index/diskann.cpp b/src/index/diskann.cpp
index 01858b4e2..6f0319099 100644
--- a/src/index/diskann.cpp
+++ b/src/index/diskann.cpp
@@ -21,6 +21,7 @@
 #include <functional>
 #include <future>
 #include <iterator>
+#include <memory>
 #include <new>
 #include <nlohmann/json.hpp>
 #include <stdexcept>
@@ -378,9 +379,9 @@ DiskANN::build(const DatasetPtr& base) {
                        [&ids](const auto& index) { return ids[index]; });
 
         disk_layout_reader_ = std::make_shared<LocalMemoryReader>(disk_layout_stream_);
-        reader_.reset(new LocalFileReader(batch_read_));
-        index_.reset(new diskann::PQFlashIndex<float, int64_t>(
-            reader_, metric_, sector_len_, dim_, use_bsa_));
+        reader_ = std::make_shared<LocalFileReader>(batch_read_);
+        index_ = std::make_shared<diskann::PQFlashIndex<float, int64_t>>(
+            reader_, metric_, sector_len_, dim_, use_bsa_);
         index_->load_from_separate_paths(
             pq_pivots_stream_, disk_pq_compressed_vectors_, tag_stream_);
         if (preload_) {
@@ -874,9 +875,9 @@ DiskANN::deserialize(const ReaderSet& reader_set) {
         }
 
         disk_layout_reader_ = reader_set.Get(DISKANN_LAYOUT_FILE);
-        reader_.reset(new LocalFileReader(batch_read_));
-        index_.reset(new diskann::PQFlashIndex<float, int64_t>(
-            reader_, metric_, sector_len_, dim_, use_bsa_));
+        reader_ = std::make_shared<LocalFileReader>(batch_read_);
+        index_ = std::make_shared<diskann::PQFlashIndex<float, int64_t>>(
+            reader_, metric_, sector_len_, dim_, use_bsa_);
         index_->load_from_separate_paths(pq_pivots_stream, disk_pq_compressed_vectors, tag_stream);
 
         auto graph_reader = reader_set.Get(DISKANN_GRAPH);
@@ -940,9 +941,9 @@ DiskANN::deserialize(const ReaderSet& reader_set) {
     }
 
     disk_layout_reader_ = reader_set.Get(DISKANN_LAYOUT_FILE);
-    reader_.reset(new LocalFileReader(batch_read_));
-    index_.reset(
-        new diskann::PQFlashIndex<float, int64_t>(reader_, metric_, sector_len_, dim_, use_bsa_));
+    reader_ = std::make_shared<LocalFileReader>(batch_read_);
+    index_ = std::make_shared<diskann::PQFlashIndex<float, int64_t>>(
+        reader_, metric_, sector_len_, dim_, use_bsa_);
     index_->load_from_separate_paths(pq_pivots_stream, disk_pq_compressed_vectors, tag_stream);
 
     auto graph_reader = reader_set.Get(DISKANN_GRAPH);
@@ -1056,9 +1057,9 @@ DiskANN::deserialize(std::istream& in_stream) {
                                             datacell_offsets[DISKANN_LAYOUT_FILE].get<uint64_t>(),
                                             datacell_sizes[DISKANN_LAYOUT_FILE].get<uint64_t>());
 
-        reader_.reset(new LocalFileReader(batch_read_));
-        index_.reset(new diskann::PQFlashIndex<float, int64_t>(
-            reader_, metric_, sector_len_, dim_, use_bsa_));
+        reader_ = std::make_shared<LocalFileReader>(batch_read_);
+        index_ = std::make_shared<diskann::PQFlashIndex<float, int64_t>>(
+            reader_, metric_, sector_len_, dim_, use_bsa_);
         index_->load_from_separate_paths(pq_pivots_stream, disk_pq_compressed_vectors, tag_stream);
 
         if (preload_) {
@@ -1349,9 +1350,9 @@ DiskANN::build_partial_graph(const DatasetPtr& base,
 tl::expected<void, Error>
 DiskANN::load_disk_index(const BinarySet& binary_set) {
     disk_layout_reader_ = std::make_shared<LocalMemoryReader>(disk_layout_stream_);
-    reader_.reset(new LocalFileReader(batch_read_));
-    index_.reset(
-        new diskann::PQFlashIndex<float, int64_t>(reader_, metric_, sector_len_, dim_, use_bsa_));
+    reader_ = std::make_shared<LocalFileReader>(batch_read_);
+    index_ = std::make_shared<diskann::PQFlashIndex<float, int64_t>>(
+        reader_, metric_, sector_len_, dim_, use_bsa_);
 
     convert_binary_to_stream(binary_set.Get(DISKANN_COMPRESSED_VECTOR),
                              disk_pq_compressed_vectors_);
diff --git a/src/index/hnsw.cpp b/src/index/hnsw.cpp
index 7614e319f..abe699f71 100644
--- a/src/index/hnsw.cpp
+++ b/src/index/hnsw.cpp
@@ -1252,7 +1252,7 @@ extract_data_and_graph(const std::vector<MergeUnit>& merge_units,
     for (const auto& merge_unit : merge_units) {
         auto stat_string = merge_unit.index->GetStats();
         auto stats = JsonType::parse(stat_string);
-        std::string index_name = stats[STATSTIC_INDEX_NAME];
+        // std::string index_name = stats[STATSTIC_INDEX_NAME];
         auto hnsw = std::dynamic_pointer_cast<HNSW>(merge_unit.index);
         hnsw->ExtractDataAndGraph(data, graph, ids, merge_unit.id_map_func, allocator);
     }
diff --git a/src/index/iterator_filter.h b/src/index/iterator_filter.h
index e42790fe3..08a224772 100644
--- a/src/index/iterator_filter.h
+++ b/src/index/iterator_filter.h
@@ -28,7 +28,7 @@ namespace vsag {
 
 class IteratorFilterContext : public IteratorContext {
 public:
-    IteratorFilterContext() : is_first_used_(true){};
+    IteratorFilterContext() : is_first_used_(true) {};
     ~IteratorFilterContext();
 
     tl::expected<void, Error>
diff --git a/src/io/async_io.cpp b/src/io/async_io.cpp
index e50c4b0e2..dbe5ffc79 100644
--- a/src/io/async_io.cpp
+++ b/src/io/async_io.cpp
@@ -44,10 +44,10 @@ AsyncIO::AsyncIO(std::string filename, Allocator* allocator)
 }
 
 AsyncIO::AsyncIO(const AsyncIOParameterPtr& io_param, const IndexCommonParam& common_param)
-    : AsyncIO(io_param->path_, common_param.allocator_.get()){};
+    : AsyncIO(io_param->path_, common_param.allocator_.get()) {};
 
 AsyncIO::AsyncIO(const IOParamPtr& param, const IndexCommonParam& common_param)
-    : AsyncIO(std::dynamic_pointer_cast<AsyncIOParameter>(param), common_param){};
+    : AsyncIO(std::dynamic_pointer_cast<AsyncIOParameter>(param), common_param) {};
 
 AsyncIO::~AsyncIO() {
     close(this->wfd_);
@@ -146,7 +146,7 @@ AsyncIO::MultiReadImpl(uint8_t* datas, uint64_t* sizes, uint64_t* offsets, uint6
         for (int64_t i = 0; i < count; ++i) {
             memcpy(cur_data, objs[i].data, sizes[i]);
             cur_data += sizes[i];
-            this->ReleaseImpl(objs[i].data);
+            vsag::AsyncIO::ReleaseImpl(objs[i].data);
         }
 
         sizes += count;
diff --git a/src/io/buffer_io.cpp b/src/io/buffer_io.cpp
index 18ddf7a82..3c2469e6f 100644
--- a/src/io/buffer_io.cpp
+++ b/src/io/buffer_io.cpp
@@ -35,10 +35,10 @@ BufferIO::BufferIO(std::string filename, Allocator* allocator)
 }
 
 BufferIO::BufferIO(const BufferIOParameterPtr& io_param, const IndexCommonParam& common_param)
-    : BufferIO(io_param->path_, common_param.allocator_.get()){};
+    : BufferIO(io_param->path_, common_param.allocator_.get()) {};
 
 BufferIO::BufferIO(const IOParamPtr& param, const IndexCommonParam& common_param)
-    : BufferIO(std::dynamic_pointer_cast<BufferIOParameter>(param), common_param){};
+    : BufferIO(std::dynamic_pointer_cast<BufferIOParameter>(param), common_param) {};
 
 void
 BufferIO::WriteImpl(const uint8_t* data, uint64_t size, uint64_t offset) {
diff --git a/src/io/io_context.h b/src/io/io_context.h
index 8edc90bbb..37f4ea119 100644
--- a/src/io/io_context.h
+++ b/src/io/io_context.h
@@ -38,7 +38,7 @@ class IOContext : public ResourceObject {
     };
 
     void
-    Reset() override{};
+    Reset() override {};
 
 public:
     static constexpr int64_t DEFAULT_REQUEST_COUNT = 100;
diff --git a/src/io/io_read_object.h b/src/io/io_read_object.h
index 734b5d4a4..13ab4b644 100644
--- a/src/io/io_read_object.h
+++ b/src/io/io_read_object.h
@@ -21,7 +21,7 @@
 
 class IOReadObject {
 public:
-    explicit IOReadObject(std::function<void(const uint8_t*)> func) : release_func_(func){};
+    explicit IOReadObject(std::function<void(const uint8_t*)> func) : release_func_(func) {};
 
     const uint8_t* data_;
 
diff --git a/src/io/mmap_io.cpp b/src/io/mmap_io.cpp
index 62f46443e..9bba3f235 100644
--- a/src/io/mmap_io.cpp
+++ b/src/io/mmap_io.cpp
@@ -43,10 +43,10 @@ MMapIO::MMapIO(std::string filename, Allocator* allocator)
 }
 
 MMapIO::MMapIO(const MMapIOParameterPtr& io_param, const IndexCommonParam& common_param)
-    : MMapIO(io_param->path_, common_param.allocator_.get()){};
+    : MMapIO(io_param->path_, common_param.allocator_.get()) {};
 
 MMapIO::MMapIO(const IOParamPtr& param, const IndexCommonParam& common_param)
-    : MMapIO(std::dynamic_pointer_cast<MMapIOParameter>(param), common_param){};
+    : MMapIO(std::dynamic_pointer_cast<MMapIOParameter>(param), common_param) {};
 
 MMapIO::~MMapIO() {
     munmap(this->start_, this->size_);
diff --git a/src/label_table.h b/src/label_table.h
index 59bd5bab9..ed18bd717 100644
--- a/src/label_table.h
+++ b/src/label_table.h
@@ -46,7 +46,7 @@ class LabelTable {
           label_remap_(0, allocator),
           use_reverse_map_(use_reverse_map),
           compress_duplicate_data_(compress_redundant_data),
-          duplicate_records_(0, allocator){};
+          duplicate_records_(0, allocator) {};
 
     ~LabelTable() {
         for (int i = 0; i < duplicate_records_.size(); ++i) {
diff --git a/src/prefetch.cpp b/src/prefetch.cpp
index 6aa86c35b..c2a2d76a8 100644
--- a/src/prefetch.cpp
+++ b/src/prefetch.cpp
@@ -23,7 +23,7 @@ namespace vsag {
 
 template <>
 void
-PrefetchImpl<0>(const void* data){};
+PrefetchImpl<0>(const void* data) {};
 
 void
 PrefetchLines(const void* data, uint64_t size) {
diff --git a/src/prefetch.h b/src/prefetch.h
index 55697da64..40c846e55 100644
--- a/src/prefetch.h
+++ b/src/prefetch.h
@@ -20,7 +20,8 @@
 
 namespace vsag {
 template <int N>
-__inline void __attribute__((__always_inline__)) PrefetchImpl(const void* data) {
+__inline void __attribute__((__always_inline__))
+PrefetchImpl(const void* data) {
     if constexpr (N > 24) {
         return PrefetchImpl<24>(data);
     }
diff --git a/src/quantization/computer.h b/src/quantization/computer.h
index f288b442a..c7745b434 100644
--- a/src/quantization/computer.h
+++ b/src/quantization/computer.h
@@ -34,7 +34,7 @@ class Computer : public ComputerInterface, public std::enable_shared_from_this<C
     }
 
     explicit Computer(const T* quantizer, Allocator* allocator)
-        : quantizer_(quantizer), allocator_(allocator){};
+        : quantizer_(quantizer), allocator_(allocator) {};
 
     ComputerInterfacePtr
     GetComputerInterfacePtr() override {
diff --git a/src/quantization/fp32_quantizer.h b/src/quantization/fp32_quantizer.h
index 484c3dc0c..3e87af6a0 100644
--- a/src/quantization/fp32_quantizer.h
+++ b/src/quantization/fp32_quantizer.h
@@ -52,10 +52,10 @@ class FP32Quantizer : public Quantizer<FP32Quantizer<metric>> {
     ComputeImpl(const uint8_t* codes1, const uint8_t* codes2);
 
     void
-    SerializeImpl(StreamWriter& writer){};
+    SerializeImpl(StreamWriter& writer) {};
 
     void
-    DeserializeImpl(StreamReader& reader){};
+    DeserializeImpl(StreamReader& reader) {};
 
     void
     ProcessQueryImpl(const DataType* query, Computer<FP32Quantizer<metric>>& computer) const;
diff --git a/src/quantization/quantizer.h b/src/quantization/quantizer.h
index 1c99f37dc..1cf9b9857 100644
--- a/src/quantization/quantizer.h
+++ b/src/quantization/quantizer.h
@@ -234,10 +234,10 @@ class Quantizer : public QuantizerInterface {
     }
 
     virtual void
-    Package32(const uint8_t* codes, uint8_t* packaged_codes, int64_t valid_size) const override{};
+    Package32(const uint8_t* codes, uint8_t* packaged_codes, int64_t valid_size) const override {};
 
     virtual void
-    Unpack32(const uint8_t* packaged_codes, uint8_t* codes) const override{};
+    Unpack32(const uint8_t* packaged_codes, uint8_t* codes) const override {};
 
     /**
      * @brief Get the size of the encoded code in bytes.
diff --git a/src/quantization/rabitq_quantization/rabitq_quantizer.cpp b/src/quantization/rabitq_quantization/rabitq_quantizer.cpp
index aa42521bb..fbfca3a95 100644
--- a/src/quantization/rabitq_quantization/rabitq_quantizer.cpp
+++ b/src/quantization/rabitq_quantization/rabitq_quantizer.cpp
@@ -15,6 +15,8 @@
 
 #include "rabitq_quantizer.h"
 
+#include <memory>
+
 #include "impl/transform/transformer_headers.h"
 #include "simd/fp32_simd.h"
 #include "simd/normalize.h"
@@ -38,9 +40,9 @@ RaBitQuantizer<metric>::RaBitQuantizer(int dim,
     original_dim_ = dim;
     if (0 < pca_dim_ and pca_dim_ < dim) {
         if (use_mrq_) {
-            pca_.reset(new PCATransformer(allocator, dim, dim));
+            pca_ = std::make_shared<PCATransformer>(allocator, dim, dim);
         } else {
-            pca_.reset(new PCATransformer(allocator, dim, pca_dim_));
+            pca_ = std::make_shared<PCATransformer>(allocator, dim, pca_dim_);
         }
         this->dim_ = pca_dim_;
     } else {
@@ -56,9 +58,9 @@ RaBitQuantizer<metric>::RaBitQuantizer(int dim,
     // random orthogonal matrix
     use_fht_ = use_fht;
     if (use_fht_) {
-        rom_.reset(new FhtKacRotator(allocator, this->dim_));
+        rom_ = std::make_shared<FhtKacRotator>(allocator, this->dim_);
     } else {
-        rom_.reset(new RandomOrthogonalMatrix(allocator, this->dim_));
+        rom_ = std::make_shared<RandomOrthogonalMatrix>(allocator, this->dim_);
     }
     // distance function related variable
     inv_sqrt_d_ = 1.0F / sqrt(this->dim_);
diff --git a/src/quantization/scalar_quantization/bf16_quantizer.h b/src/quantization/scalar_quantization/bf16_quantizer.h
index 01636de6f..ad8631510 100644
--- a/src/quantization/scalar_quantization/bf16_quantizer.h
+++ b/src/quantization/scalar_quantization/bf16_quantizer.h
@@ -66,10 +66,10 @@ class BF16Quantizer : public Quantizer<BF16Quantizer<metric>> {
     ReleaseComputerImpl(Computer<BF16Quantizer<metric>>& computer) const;
 
     void
-    SerializeImpl(StreamWriter& writer){};
+    SerializeImpl(StreamWriter& writer) {};
 
     void
-    DeserializeImpl(StreamReader& reader){};
+    DeserializeImpl(StreamReader& reader) {};
 
     [[nodiscard]] std::string
     NameImpl() const {
diff --git a/src/quantization/scalar_quantization/fp16_quantizer.h b/src/quantization/scalar_quantization/fp16_quantizer.h
index 09817c355..fcd573aeb 100644
--- a/src/quantization/scalar_quantization/fp16_quantizer.h
+++ b/src/quantization/scalar_quantization/fp16_quantizer.h
@@ -66,10 +66,10 @@ class FP16Quantizer : public Quantizer<FP16Quantizer<metric>> {
     ReleaseComputerImpl(Computer<FP16Quantizer<metric>>& computer) const;
 
     void
-    SerializeImpl(StreamWriter& writer){};
+    SerializeImpl(StreamWriter& writer) {};
 
     void
-    DeserializeImpl(StreamReader& reader){};
+    DeserializeImpl(StreamReader& reader) {};
 
     [[nodiscard]] std::string
     NameImpl() const {
diff --git a/src/simd/.clang-tidy b/src/simd/.clang-tidy
index d75711fcb..f1e234e5f 100644
--- a/src/simd/.clang-tidy
+++ b/src/simd/.clang-tidy
@@ -22,7 +22,7 @@ Checks: >
 
 HeaderFilterRegex: ''
 WarningsAsErrors: "*"
-AnalyzeTemporaryDtors: true
+# AnalyzeTemporaryDtors: true
 
 CheckOptions:
   - { key: readability-identifier-naming.NamespaceCase,               value: lower_case }
diff --git a/src/simd/CMakeLists.txt b/src/simd/CMakeLists.txt
index cd022dfbd..540c12466 100644
--- a/src/simd/CMakeLists.txt
+++ b/src/simd/CMakeLists.txt
@@ -40,7 +40,7 @@ if (DIST_CONTAINS_AVX512)
             avx512.cpp
             PROPERTIES
             COMPILE_FLAGS
-            "-mavx512f -mavx512pf -mavx512er -mavx512cd -mavx512vl -mavx512bw -mavx512dq -mavx512ifma -mavx512vbmi"
+            "-Wno-knl-knm-isa-support-removed -mavx512f -mavx512pf -mavx512er -mavx512cd -mavx512vl -mavx512bw -mavx512dq -mavx512ifma -mavx512vbmi"
     )
 endif ()
 if (DIST_CONTAINS_AVX512VPOPCNTDQ)
@@ -48,7 +48,7 @@ if (DIST_CONTAINS_AVX512VPOPCNTDQ)
             avx512vpopcntdq.cpp
             PROPERTIES
             COMPILE_FLAGS
-            "-mavx512f -mavx512pf -mavx512er -mavx512cd -mavx512vl -mavx512bw -mavx512dq -mavx512ifma -mavx512vbmi -mavx512vpopcntdq"
+            "-Wno-knl-knm-isa-support-removed -mavx512f -mavx512pf -mavx512er -mavx512cd -mavx512vl -mavx512bw -mavx512dq -mavx512ifma -mavx512vbmi -mavx512vpopcntdq"
     )
 endif ()
 if (DIST_CONTAINS_NEON)
diff --git a/src/simd/avx.cpp b/src/simd/avx.cpp
index bff227212..0964d40b8 100644
--- a/src/simd/avx.cpp
+++ b/src/simd/avx.cpp
@@ -86,7 +86,8 @@ PQDistanceFloat256(const void* single_dim_centers, float single_dim_val, void* r
 }
 
 #if defined(ENABLE_AVX)
-__inline __m256i __attribute__((__always_inline__)) load_8_char_and_convert(const uint8_t* data) {
+__inline __m256i __attribute__((__always_inline__))
+load_8_char_and_convert(const uint8_t* data) {
     __m128i first_8 =
         _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, data[3], data[2], data[1], data[0]);
     __m128i second_8 =
@@ -369,7 +370,8 @@ FP32ReduceAdd(const float* x, uint64_t dim) {
 }
 
 #if defined(ENABLE_AVX)
-__inline __m256i __attribute__((__always_inline__)) load_8_short(const uint16_t* data) {
+__inline __m256i __attribute__((__always_inline__))
+load_8_short(const uint16_t* data) {
     return _mm256_set_epi16(data[7],
                             0,
                             data[6],
diff --git a/src/simd/avx2.cpp b/src/simd/avx2.cpp
index b43370d78..43305eb30 100644
--- a/src/simd/avx2.cpp
+++ b/src/simd/avx2.cpp
@@ -86,7 +86,8 @@ PQDistanceFloat256(const void* single_dim_centers, float single_dim_val, void* r
 }
 
 #if defined(ENABLE_AVX2)
-__inline __m128i __attribute__((__always_inline__)) load_8_char(const uint8_t* data) {
+__inline __m128i __attribute__((__always_inline__))
+load_8_char(const uint8_t* data) {
     return _mm_loadl_epi64(reinterpret_cast<const __m128i*>(data));
 }
 #endif
@@ -362,7 +363,8 @@ FP32ReduceAdd(const float* x, uint64_t dim) {
 }
 
 #if defined(ENABLE_AVX2)
-__inline __m256i __attribute__((__always_inline__)) load_8_short(const uint16_t* data) {
+__inline __m256i __attribute__((__always_inline__))
+load_8_short(const uint16_t* data) {
     __m128i bf16 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(data));
     __m256i bf32 = _mm256_cvtepu16_epi32(bf16);
     return _mm256_slli_epi32(bf32, 16);
diff --git a/src/simd/avx512.cpp b/src/simd/avx512.cpp
index b2b5f88ae..e7b5f8f3e 100644
--- a/src/simd/avx512.cpp
+++ b/src/simd/avx512.cpp
@@ -406,7 +406,8 @@ FP32ReduceAdd(const float* x, uint64_t dim) {
 }
 
 #if defined(ENABLE_AVX512)
-__inline __m512i __attribute__((__always_inline__)) load_16_short(const uint16_t* data) {
+__inline __m512i __attribute__((__always_inline__))
+load_16_short(const uint16_t* data) {
     __m256i bf16 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(data));
     __m512i bf32 = _mm512_cvtepu16_epi32(bf16);
     return _mm512_slli_epi32(bf32, 16);
diff --git a/src/simd/generic.cpp b/src/simd/generic.cpp
index eda9d2e9a..7bcb1390b 100644
--- a/src/simd/generic.cpp
+++ b/src/simd/generic.cpp
@@ -592,7 +592,7 @@ DivScalar(const float* from, float* to, uint64_t dim, float scalar) {
 }
 
 void
-Prefetch(const void* data){};
+Prefetch(const void* data) {};
 
 void
 PQFastScanLookUp32(const uint8_t* RESTRICT lookup_table,
diff --git a/src/simd/neon.cpp b/src/simd/neon.cpp
index ba4ccf2f1..f6bc85a39 100644
--- a/src/simd/neon.cpp
+++ b/src/simd/neon.cpp
@@ -72,7 +72,8 @@ INT8InnerProductDistance(const void* pVect1v, const void* pVect2v, const void* q
 }
 
 #if defined(ENABLE_NEON)
-__inline float32x4x3_t __attribute__((__always_inline__)) vcvt3_f32_f16(const float16x4x3_t a) {
+__inline float32x4x3_t __attribute__((__always_inline__))
+vcvt3_f32_f16(const float16x4x3_t a) {
     float32x4x3_t c;
     c.val[0] = vcvt_f32_f16(a.val[0]);
     c.val[1] = vcvt_f32_f16(a.val[1]);
@@ -80,14 +81,16 @@ __inline float32x4x3_t __attribute__((__always_inline__)) vcvt3_f32_f16(const fl
     return c;
 }
 
-__inline float32x4x2_t __attribute__((__always_inline__)) vcvt2_f32_f16(const float16x4x2_t a) {
+__inline float32x4x2_t __attribute__((__always_inline__))
+vcvt2_f32_f16(const float16x4x2_t a) {
     float32x4x2_t c;
     c.val[0] = vcvt_f32_f16(a.val[0]);
     c.val[1] = vcvt_f32_f16(a.val[1]);
     return c;
 }
 
-__inline float32x4x3_t __attribute__((__always_inline__)) vcvt3_f32_half(const uint16x4x3_t x) {
+__inline float32x4x3_t __attribute__((__always_inline__))
+vcvt3_f32_half(const uint16x4x3_t x) {
     float32x4x3_t c;
     c.val[0] = vreinterpretq_f32_u32(vshlq_n_u32(vmovl_u16(x.val[0]), 16));
     c.val[1] = vreinterpretq_f32_u32(vshlq_n_u32(vmovl_u16(x.val[1]), 16));
@@ -95,13 +98,15 @@ __inline float32x4x3_t __attribute__((__always_inline__)) vcvt3_f32_half(const u
     return c;
 }
 
-__inline float32x4x2_t __attribute__((__always_inline__)) vcvt2_f32_half(const uint16x4x2_t x) {
+__inline float32x4x2_t __attribute__((__always_inline__))
+vcvt2_f32_half(const uint16x4x2_t x) {
     float32x4x2_t c;
     c.val[0] = vreinterpretq_f32_u32(vshlq_n_u32(vmovl_u16(x.val[0]), 16));
     c.val[1] = vreinterpretq_f32_u32(vshlq_n_u32(vmovl_u16(x.val[1]), 16));
     return c;
 }
-__inline float32x4_t __attribute__((__always_inline__)) vcvt_f32_half(const uint16x4_t x) {
+__inline float32x4_t __attribute__((__always_inline__))
+vcvt_f32_half(const uint16x4_t x) {
     return vreinterpretq_f32_u32(vshlq_n_u32(vmovl_u16(x), 16));
 }
 
@@ -501,7 +506,8 @@ FP32ReduceAdd(const float* x, uint64_t dim) {
 }
 
 #if defined(ENABLE_NEON)
-__inline uint16x8_t __attribute__((__always_inline__)) load_4_short(const uint16_t* data) {
+__inline uint16x8_t __attribute__((__always_inline__))
+load_4_short(const uint16_t* data) {
     uint16_t tmp[] = {data[3], 0, data[2], 0, data[1], 0, data[0], 0};
     return vld1q_u16(tmp);
 }
@@ -795,7 +801,8 @@ FP16ComputeL2Sqr(const uint8_t* RESTRICT query, const uint8_t* RESTRICT codes, u
 }
 
 #if defined(ENABLE_NEON)
-__inline float32x4_t __attribute__((__always_inline__)) load_4_uint8_to_float(const uint8_t* data) {
+__inline float32x4_t __attribute__((__always_inline__))
+load_4_uint8_to_float(const uint8_t* data) {
     uint32x4_t code_values = {data[0], data[1], data[2], data[3]};
     return vcvtq_f32_u32(code_values);
 }
@@ -810,7 +817,8 @@ load_8_uint8_to_float(const uint8_t* data, float32x4_t& low, float32x4_t& high)
     high = vcvtq_f32_u32(code_32_high);
 }
 
-__inline void __attribute__((__always_inline__)) load_16_uint8_to_float(
+__inline void __attribute__((__always_inline__))
+load_16_uint8_to_float(
     const uint8_t* data, float32x4_t& f0, float32x4_t& f1, float32x4_t& f2, float32x4_t& f3) {
     uint8x16_t code_vec = vld1q_u8(data);
     uint16x8_t code_16_low = vmovl_u8(vget_low_u8(code_vec));
@@ -1589,11 +1597,12 @@ SQ8UniformComputeCodesIP(const uint8_t* codes1, const uint8_t* codes2, uint64_t
 }
 
 #if defined(ENABLE_NEON)
-__inline void __attribute__((__always_inline__)) extract_12_bits_to_mask(const uint8_t* bits,
-                                                                         size_t bit_offset,
-                                                                         uint32x4_t& mask0,
-                                                                         uint32x4_t& mask1,
-                                                                         uint32x4_t& mask2) {
+__inline void __attribute__((__always_inline__))
+extract_12_bits_to_mask(const uint8_t* bits,
+                        size_t bit_offset,
+                        uint32x4_t& mask0,
+                        uint32x4_t& mask1,
+                        uint32x4_t& mask2) {
     size_t byte_idx = bit_offset / 8;
     size_t bit_start = bit_offset % 8;
 
@@ -1625,10 +1634,11 @@ __inline void __attribute__((__always_inline__)) extract_12_bits_to_mask(const u
                          (mask_bits & 0x800) ? 0xFFFFFFFF : 0};
 }
 
-__inline void __attribute__((__always_inline__)) extract_8_bits_to_mask(const uint8_t* bits,
-                                                                        size_t bit_offset,
-                                                                        uint32x4_t& mask0,
-                                                                        uint32x4_t& mask1) {
+__inline void __attribute__((__always_inline__))
+extract_8_bits_to_mask(const uint8_t* bits,
+                       size_t bit_offset,
+                       uint32x4_t& mask0,
+                       uint32x4_t& mask1) {
     size_t byte_idx = bit_offset / 8;
     size_t bit_start = bit_offset % 8;
 
diff --git a/src/simd/sse.cpp b/src/simd/sse.cpp
index a8d3bca57..a302d0bbe 100644
--- a/src/simd/sse.cpp
+++ b/src/simd/sse.cpp
@@ -85,13 +85,15 @@ PQDistanceFloat256(const void* single_dim_centers, float single_dim_val, void* r
 }
 
 #if defined(ENABLE_SSE)
-__inline __m128i __attribute__((__always_inline__)) load_4_char(const uint8_t* data) {
+__inline __m128i __attribute__((__always_inline__))
+load_4_char(const uint8_t* data) {
     return _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, data[3], data[2], data[1], data[0]);
 }
 #endif
 
 #if defined(ENABLE_SSE)
-__inline __m128i __attribute__((__always_inline__)) load_4_short(const uint16_t* data) {
+__inline __m128i __attribute__((__always_inline__))
+load_4_short(const uint16_t* data) {
     return _mm_set_epi16(data[3], 0, data[2], 0, data[1], 0, data[0], 0);
 }
 #endif
diff --git a/src/storage/stream_reader.cpp b/src/storage/stream_reader.cpp
index 24208054b..f8f60f942 100644
--- a/src/storage/stream_reader.cpp
+++ b/src/storage/stream_reader.cpp
@@ -60,7 +60,7 @@ ReadFuncStreamReader::ReadFuncStreamReader(std::function<void(uint64_t, uint64_t
 
 void
 IOStreamReader::Read(char* data, uint64_t size) {
-    auto offset = std::to_string(istream_.tellg());
+    // auto offset = std::to_string(istream_.tellg());
     // vsag::logger::trace("io read offset {} size {}", offset, size);
     this->istream_.read(data, static_cast<int64_t>(size));
     if (istream_.fail()) {
diff --git a/src/utils/timer.cpp b/src/utils/timer.cpp
index 19859de72..1cd29c23e 100644
--- a/src/utils/timer.cpp
+++ b/src/utils/timer.cpp
@@ -23,9 +23,9 @@ Timer::Timer(double* ref) : ref_(ref) {
     this->threshold_ = std::numeric_limits<double>::max();
 }
 
-Timer::Timer(double& ref) : Timer(&ref){};
+Timer::Timer(double& ref) : Timer(&ref) {};
 
-Timer::Timer() : Timer(nullptr){};
+Timer::Timer() : Timer(nullptr) {};
 
 double
 Timer::Record() {
diff --git a/src/utils/util_functions.cpp b/src/utils/util_functions.cpp
index b219e32cc..d6323bfde 100644
--- a/src/utils/util_functions.cpp
+++ b/src/utils/util_functions.cpp
@@ -59,7 +59,7 @@ mapping_external_param_to_inner(const JsonType& external_json,
 std::tuple<DatasetPtr, float*, int64_t*>
 create_fast_dataset(int64_t dim, Allocator* allocator) {
     auto dataset = Dataset::Make();
-    dataset->Dim(static_cast<int64_t>(dim))->NumElements(1)->Owner(true, allocator);
+    dataset->Dim(dim)->NumElements(1)->Owner(true, allocator);
     auto* ids = reinterpret_cast<int64_t*>(allocator->Allocate(sizeof(int64_t) * dim));
     dataset->Ids(ids);
     auto* dists = reinterpret_cast<float*>(allocator->Allocate(sizeof(float) * dim));
diff --git a/src/vsag_exception.h b/src/vsag_exception.h
index b11a9429d..11e5e842a 100644
--- a/src/vsag_exception.h
+++ b/src/vsag_exception.h
@@ -22,7 +22,7 @@
 namespace vsag {
 class VsagException : std::exception {
 public:
-    explicit VsagException(Error& error) : error_(error){};
+    explicit VsagException(Error& error) : error_(error) {};
 
     template <typename... Args>
     explicit VsagException(ErrorType error_type, Args&&... args)
diff --git a/tools/eval/monitor/monitor.h b/tools/eval/monitor/monitor.h
index b963e1e97..14e2a821e 100644
--- a/tools/eval/monitor/monitor.h
+++ b/tools/eval/monitor/monitor.h
@@ -49,7 +49,7 @@ class Monitor {
 
 public:
     virtual void
-    Record(void* input = nullptr){};
+    Record(void* input = nullptr) {};
 
 public:
     std::string name_{};