diff --git a/CMakeLists.txt b/CMakeLists.txt
index c04d9bd..1599544 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -24,7 +24,7 @@ option(BUILD_BENCHMARK "Build benchmark" ON)
 option(BUILD_INTEGRATION_TESTS "Build integration test" ON)
 option(BUILD_UNIT_TESTS "Build unit test" ON)
 option(BUILD_SDK_EXAMPLE "Build sdk example" ON)
-option(BUILD_PYTHON_SDK "Build python sdk" OFF)
+option(BUILD_PYTHON_SDK "Build python sdk" ON)
 option(DINGOSDK_INSTALL "Intall dingosdk header and libary" ON)
 
 set(CMAKE_CXX_STANDARD 17)
diff --git a/include/dingosdk/document.h b/include/dingosdk/document.h
index f310949..a3b9f55 100644
--- a/include/dingosdk/document.h
+++ b/include/dingosdk/document.h
@@ -95,7 +95,7 @@ class DocValue {
   double DoubleValue() const;
   std::string StringValue() const;
   std::string BytesValue() const;
-  bool BoolValue()const;
+  bool BoolValue() const;
   std::string DatetimeValue() const;
 
   std::string ToString() const;
@@ -157,6 +157,8 @@ struct DocSearchParam {
   std::vector<std::string> column_names;
   bool with_scalar_data{false};
   std::vector<std::string> selected_keys;
+  //search all need limit
+  int32_t query_unlimited{40960};
 };
 
 struct DocWithStore {
@@ -229,6 +231,10 @@ class DocumentClient {
   Status SearchByIndexName(int64_t schema_id, const std::string& index_name, const DocSearchParam& search_param,
                            DocSearchResult& out_result);
 
+  Status SearchAllByIndexId(int64_t index_id, const DocSearchParam& search_param, DocSearchResult& out_result);
+  Status SearchAllByIndexName(int64_t schema_id, const std::string& index_name, const DocSearchParam& search_param,
+                           DocSearchResult& out_result);
+
   Status DeleteByIndexId(int64_t index_id, const std::vector<int64_t>& doc_ids,
                          std::vector<DocDeleteResult>& out_result);
   Status DeleteByIndexName(int64_t schema_id, const std::string& index_name, const std::vector<int64_t>& doc_ids,
diff --git a/src/example/sdk_document_example.cc b/src/example/sdk_document_example.cc
index 327f946..bd4674e 100644
--- a/src/example/sdk_document_example.cc
+++ b/src/example/sdk_document_example.cc
@@ -340,6 +340,149 @@ static void DocumentSearch(bool use_index_name = false) {
   }
 }
 
+static void DocumentSearchAll(bool use_index_name = false) {
+  {
+    dingodb::sdk::DocSearchParam param;
+    param.with_scalar_data = true;
+    param.query_string = "discover";
+    param.use_id_filter = false;
+
+    Status tmp;
+    DocSearchResult result;
+    if (use_index_name) {
+      tmp = g_doc_client->SearchAllByIndexName(g_schema_id, g_index_name, param, result);
+    } else {
+      tmp = g_doc_client->SearchAllByIndexId(g_index_id, param, result);
+    }
+
+    DINGO_LOG(INFO) << "vector search discover status: " << tmp.ToString();
+    DINGO_LOG(INFO) << "vector search discover result:" << result.ToString();
+    if (tmp.ok()) {
+      CHECK_EQ(result.doc_sores.size(), 1);
+    }
+  }
+
+  {
+    dingodb::sdk::DocSearchParam param;
+    param.with_scalar_data = true;
+    param.query_string = "of";
+    param.use_id_filter = false;
+
+    Status tmp;
+    DocSearchResult result;
+    if (use_index_name) {
+      tmp = g_doc_client->SearchAllByIndexName(g_schema_id, g_index_name, param, result);
+    } else {
+      tmp = g_doc_client->SearchAllByIndexId(g_index_id, param, result);
+    }
+
+    DINGO_LOG(INFO) << "vector search of with limit 10 status: " << tmp.ToString();
+    DINGO_LOG(INFO) << "vector search of with limit 10 result:" << result.ToString();
+    if (tmp.ok()) {
+      CHECK_EQ(result.doc_sores.size(), 5);
+    }
+  }
+
+  {
+    dingodb::sdk::DocSearchParam param;
+    param.with_scalar_data = true;
+    param.query_string = "of";
+    param.use_id_filter = true;
+    param.query_unlimited = 4096;
+    param.doc_ids = {
+        13,
+        15,
+    };
+
+    Status tmp;
+    DocSearchResult result;
+    if (use_index_name) {
+      tmp = g_doc_client->SearchAllByIndexName(g_schema_id, g_index_name, param, result);
+    } else {
+      tmp = g_doc_client->SearchAllByIndexId(g_index_id, param, result);
+    }
+
+    DINGO_LOG(INFO) << "vector search of with id filter status: " << tmp.ToString();
+    DINGO_LOG(INFO) << "vector search of with id filter result:" << result.ToString();
+    if (tmp.ok()) {
+      CHECK_EQ(result.doc_sores.size(), 2);
+    }
+  }
+
+  {
+    dingodb::sdk::DocSearchParam param;
+    param.with_scalar_data = true;
+    param.query_string = R"(text:"of" AND i64: >= 1013)";
+    param.use_id_filter = true;
+    param.query_unlimited = 4096;
+    param.doc_ids = {
+        9,
+        11,
+        13,
+        15,
+    };
+
+    Status tmp;
+    DocSearchResult result;
+    if (use_index_name) {
+      tmp = g_doc_client->SearchAllByIndexName(g_schema_id, g_index_name, param, result);
+    } else {
+      tmp = g_doc_client->SearchAllByIndexId(g_index_id, param, result);
+    }
+
+    DINGO_LOG(INFO) << "vector search of with id filter status: " << tmp.ToString();
+    DINGO_LOG(INFO) << "vector search of with id filter result:" << result.ToString();
+    if (tmp.ok()) {
+      CHECK_EQ(result.doc_sores.size(), 2);
+    }
+  }
+
+  {
+    dingodb::sdk::DocSearchParam param;
+    param.with_scalar_data = true;
+    param.query_string = R"( bool:true)";
+    param.use_id_filter = true;
+    param.doc_ids = {15, 17, 19, 21};
+    param.query_unlimited = 4096;
+
+    Status tmp;
+    DocSearchResult result;
+    if (use_index_name) {
+      tmp = g_doc_client->SearchAllByIndexName(g_schema_id, g_index_name, param, result);
+    } else {
+      tmp = g_doc_client->SearchAllByIndexId(g_index_id, param, result);
+    }
+
+    DINGO_LOG(INFO) << "vector search of with id filter status: " << tmp.ToString();
+    DINGO_LOG(INFO) << "vector search of with id filter result:" << result.ToString();
+    if (tmp.ok()) {
+      CHECK_EQ(result.doc_sores.size(), 2);
+    }
+  }
+
+  {
+    dingodb::sdk::DocSearchParam param;
+    param.with_scalar_data = true;
+    param.query_string = fmt::format("{}:\"{}\"", "datetime", time_1);
+    param.use_id_filter = true;
+    param.doc_ids = {9, 11, 13, 15};
+
+    Status tmp;
+    DocSearchResult result;
+    if (use_index_name) {
+      tmp = g_doc_client->SearchAllByIndexName(g_schema_id, g_index_name, param, result);
+    } else {
+      tmp = g_doc_client->SearchAllByIndexId(g_index_id, param, result);
+    }
+
+    DINGO_LOG(INFO) << "vector search of with id filter status: " << tmp.ToString();
+    DINGO_LOG(INFO) << "vector search of with id filter result:" << result.ToString();
+    if (tmp.ok()) {
+      CHECK_EQ(result.doc_sores.size(), 4);
+    }
+  }
+}
+
 static void DocumentQuey(bool use_index_name = false) {
   dingodb::sdk::DocQueryParam param;
   param.doc_ids = g_doc_ids;
@@ -578,6 +721,7 @@ int main(int argc, char* argv[]) {
 
     DocumentAdd();
     DocumentSearch();
+    DocumentSearchAll();
     DocumentQuey();
     DocumentGetBorder();
     DocumentScanQuery();
@@ -594,6 +738,7 @@ int main(int argc, char* argv[]) {
 
     DocumentAdd(true);
     DocumentSearch(true);
+    DocumentSearchAll(true);
     DocumentQuey(true);
     DocumentGetBorder(true);
     DocumentScanQuery(true);
diff --git a/src/sdk/CMakeLists.txt b/src/sdk/CMakeLists.txt
index b03ba60..4e2a9c3 100644
--- a/src/sdk/CMakeLists.txt
+++ b/src/sdk/CMakeLists.txt
@@ -84,6 +84,7 @@ set(SDK_SRCS
   document/document_get_index_metrics_task.cc
   document/document_scan_query_task.cc
   document/document_search_task.cc
+  document/document_search_all_task.cc
   document/document_update_task.cc
   document/document_get_auto_increment_id_task.cc
   document/document_update_auto_increment_task.cc
diff --git a/src/sdk/document/document_client.cc b/src/sdk/document/document_client.cc
index 138f07d..5062a0c 100644
--- a/src/sdk/document/document_client.cc
+++ b/src/sdk/document/document_client.cc
@@ -25,6 +25,7 @@
 #include "sdk/document/document_get_index_metrics_task.h"
 #include "sdk/document/document_index_cache.h"
 #include "sdk/document/document_scan_query_task.h"
+#include "sdk/document/document_search_all_task.h"
 #include "sdk/document/document_search_task.h"
 #include "sdk/document/document_update_auto_increment_task.h"
 #include "sdk/document/document_update_task.h"
@@ -82,6 +83,22 @@ Status DocumentClient::SearchByIndexName(int64_t schema_id, const std::string& i
   return task.Run();
 }
 
+Status DocumentClient::SearchAllByIndexId(int64_t index_id, const DocSearchParam& search_param,
+                                       DocSearchResult& out_result) {
+  DocumentSearchAllTask task(stub_, index_id, search_param, out_result);
+  return task.Run();
+}
+
+Status DocumentClient::SearchAllByIndexName(int64_t schema_id, const std::string& index_name,
+                                         const DocSearchParam& search_param, DocSearchResult& out_result) {
+  int64_t index_id{0};
+  DINGO_RETURN_NOT_OK(
+      stub_.GetDocumentIndexCache()->GetIndexIdByKey(EncodeDocumentIndexCacheKey(schema_id, index_name), index_id));
+  CHECK_GT(index_id, 0);
+  DocumentSearchAllTask task(stub_, index_id, search_param, out_result);
+  return task.Run();
+}
+
 Status DocumentClient::DeleteByIndexId(int64_t index_id, const std::vector<int64_t>& doc_ids,
                                        std::vector<DocDeleteResult>& out_result) {
   DocumentDeleteTask task(stub_, index_id, doc_ids, out_result);
diff --git a/src/sdk/document/document_search_all_task.cc b/src/sdk/document/document_search_all_task.cc
new file mode 100644
index 0000000..65e6823
--- /dev/null
+++ b/src/sdk/document/document_search_all_task.cc
@@ -0,0 +1,237 @@
+// Copyright (c) 2023 dingodb.com, Inc. All Rights Reserved
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "sdk/document/document_search_all_task.h"
+
+#include <cstdint>
+#include <iterator>
+#include <memory>
+
+#include "common/logging.h"
+#include "dingosdk/document.h"
+#include "dingosdk/status.h"
+#include "glog/logging.h"
+#include "proto/common.pb.h"
+#include "proto/document.pb.h"
+#include "sdk/common/common.h"
+#include "sdk/document/document_translater.h"
+#include "sdk/utils/scoped_cleanup.h"
+
+namespace dingodb {
+namespace sdk {
+
+Status DocumentSearchAllTask::Init() {
+  std::unique_lock<std::shared_mutex> w(rw_lock_);
+
+  std::shared_ptr<DocumentIndex> tmp;
+  DINGO_RETURN_NOT_OK(stub.GetDocumentIndexCache()->GetDocumentIndexById(index_id_, tmp));
+  DCHECK_NOTNULL(tmp);
+  doc_index_ = std::move(tmp);
+
+  auto part_ids = doc_index_->GetPartitionIds();
+
+  for (const auto& part_id : part_ids) {
+    next_part_ids_.emplace(part_id);
+  }
+
+  return Status::OK();
+}
+
+void DocumentSearchAllTask::DoAsync() {
+  std::set<int64_t> next_part_ids;
+  {
+    std::unique_lock<std::shared_mutex> w(rw_lock_);
+    next_part_ids = next_part_ids_;
+    status_ = Status::OK();
+  }
+
+  if (next_part_ids.empty()) {
+    DoAsyncDone(Status::OK());
+    return;
+  }
+
+  sub_tasks_count_.store(next_part_ids.size());
+
+  for (const auto& part_id : next_part_ids) {
+    auto* sub_task = new DocumentSearchAllPartTask(stub, index_id_, part_id, search_param_);
+    sub_task->AsyncRun([this, sub_task](auto&& s) { SubTaskCallback(std::forward<decltype(s)>(s), sub_task); });
+  }
+}
+
+void DocumentSearchAllTask::SubTaskCallback(Status status, DocumentSearchAllPartTask* sub_task) {
+  SCOPED_CLEANUP({ delete sub_task; });
+
+  if (!status.ok()) {
+    DINGO_LOG(WARNING) << "sub_task: " << sub_task->Name() << " fail: " << status.ToString();
+
+    std::unique_lock<std::shared_mutex> w(rw_lock_);
+    if (status_.ok()) {
+      // only return first fail status
+      status_ = status;
+    }
+  } else {
+    std::unique_lock<std::shared_mutex> w(rw_lock_);
+    std::vector<DocWithStore> sub_results = sub_task->GetDocSearchResult();
+    std::move(sub_results.begin(), sub_results.end(), std::back_inserter(out_result_.doc_sores));
+    next_part_ids_.erase(sub_task->part_id_);
+  }
+
+  if (sub_tasks_count_.fetch_sub(1) == 1) {
+    Status tmp;
+    {
+      std::unique_lock<std::shared_mutex> w(rw_lock_);
+
+      std::sort(out_result_.doc_sores.begin(), out_result_.doc_sores.end(),
+                [](const DocWithStore& a, const DocWithStore& b) { return a.score > b.score; });
+
+      if (search_param_.top_n > 0 && search_param_.top_n < out_result_.doc_sores.size()) {
+        out_result_.doc_sores.resize(search_param_.top_n);
+      }
+
+      tmp = status_;
+    }
+
+    DoAsyncDone(tmp);
+  }
+}
+
+Status DocumentSearchAllPartTask::Init() {
+  std::shared_ptr<DocumentIndex> tmp;
+  DINGO_RETURN_NOT_OK(stub.GetDocumentIndexCache()->GetDocumentIndexById(index_id_, tmp));
+  DCHECK_NOTNULL(tmp);
+  doc_index_ = std::move(tmp);
+
+  return Status::OK();
+}
+
+void DocumentSearchAllPartTask::DoAsync() {
+  const auto& range = doc_index_->GetPartitionRange(part_id_);
+  std::vector<std::shared_ptr<Region>> regions;
+  Status s = stub.GetMetaCache()->ScanRegionsBetweenContinuousRange(range.start_key(), range.end_key(), regions);
+  if (!s.ok()) {
+    DoAsyncDone(s);
+    return;
+  }
+
+  {
+    std::unique_lock<std::shared_mutex> w(rw_lock_);
+    search_result_.clear();
+    status_ = Status::OK();
+  }
+
+  controllers_.clear();
+  rpcs_.clear();
+
+  for (const auto& region : regions) {
+    auto rpc = std::make_unique<DocumentSearchAllRpc>();
+    FillDocumentSearchAllRpcRequest(rpc->MutableRequest(), region);
+    region_id_to_region_.insert({region->RegionId(), region});
+
+    StoreRpcController controller(stub, *rpc, region);
+    controllers_.push_back(controller);
+
+    rpcs_.push_back(std::move(rpc));
+  }
+
+  DCHECK_EQ(rpcs_.size(), regions.size());
+  DCHECK_EQ(rpcs_.size(), controllers_.size());
+
+  sub_tasks_count_.store(regions.size());
+
+  for (auto i = 0; i < regions.size(); i++) {
+    auto& controller = controllers_[i];
+
+    controller.AsyncCall(
+        [this, rpc = rpcs_[i].get()](auto&& s) { DocumentSearchAllRpcCallback(std::forward<decltype(s)>(s), rpc); });
+  }
+}
+
+void DocumentSearchAllPartTask::FillDocumentSearchAllRpcRequest(pb::document::DocumentSearchAllRequest* request,
+                                                                const std::shared_ptr<Region>& region) {
+  FillRpcContext(*request->mutable_context(), region->RegionId(), region->Epoch());
+
+  pb::common::DocumentSearchParameter search_parameter;
+  DocumentTranslater::FillInternalDocSearchAllParams(&search_parameter, search_param_);
+  *(request->mutable_parameter()) = search_parameter;
+
+  request->mutable_stream_meta()->set_limit(search_param_.query_unlimited);
+}
+
+void DocumentSearchAllPartTask::DocumentSearchAllRpcCallback(const Status& status, DocumentSearchAllRpc* rpc) {
+  if (!status.ok()) {
+    DINGO_LOG(WARNING) << "rpc: " << rpc->Method() << " send to region: " << rpc->Request()->context().region_id()
+                       << " fail: " << status.ToString();
+
+    std::unique_lock<std::shared_mutex> w(rw_lock_);
+    if (status_.ok()) {
+      // only return first fail status
+      status_ = status;
+    }
+  } else {
+    {
+      std::unique_lock<std::shared_mutex> w(rw_lock_);
+      for (const auto& doc_with_score : rpc->Response()->document_with_scores()) {
+        DocWithStore distance = DocumentTranslater::InternalDocumentWithScore2DocWithStore(doc_with_score);
+        search_result_.push_back(std::move(distance));
+      }
+    }
+  }
+  if (!rpc->Response()->stream_meta().stream_id().empty() && rpc->Response()->stream_meta().has_more()) {
+    DocumentSearchStream(rpc);
+  }
+
+  if (sub_tasks_count_.fetch_sub(1) == 1) {
+    Status tmp;
+    {
+      std::shared_lock<std::shared_mutex> r(rw_lock_);
+      tmp = status_;
+    }
+    DoAsyncDone(tmp);
+  }
+}
+
+void DocumentSearchAllPartTask::DocumentSearchStream(DocumentSearchAllRpc* rpc) {
+  auto sub_rpc = std::make_unique<DocumentSearchAllRpc>();
+  auto* request = sub_rpc->MutableRequest();
+  auto region = region_id_to_region_[rpc->Request()->context().region_id()];
+  FillDocumentSearchAllRpcRequest(sub_rpc->MutableRequest(), region);
+  request->mutable_stream_meta()->set_stream_id(rpc->Response()->stream_meta().stream_id());
+  StoreRpcController controller(stub, *sub_rpc, region);
+  controller.AsyncCall(
+      [this, rpc = sub_rpc.get()](auto&& s) { DocumentSearchStreamCallback(std::forward<decltype(s)>(s), rpc); });
+}
+
+void DocumentSearchAllPartTask::DocumentSearchStreamCallback(const Status& status, DocumentSearchAllRpc* rpc) {
+  if (!status.ok()) {
+    DINGO_LOG(WARNING) << "rpc: " << rpc->Method() << " send to region: " << rpc->Request()->context().region_id()
+                       << " fail: " << status.ToString();
+
+    std::unique_lock<std::shared_mutex> w(rw_lock_);
+    if (status_.ok()) {
+      // only return first fail status
+      status_ = status;
+    }
+  } else {
+    {
+      std::unique_lock<std::shared_mutex> w(rw_lock_);
+      for (const auto& doc_with_score : rpc->Response()->document_with_scores()) {
+        DocWithStore distance = DocumentTranslater::InternalDocumentWithScore2DocWithStore(doc_with_score);
+        search_result_.push_back(std::move(distance));
+      }
+    }
+  }
+}
+
+}  // namespace sdk
+}  // namespace dingodb
\ No newline at end of file
diff --git a/src/sdk/document/document_search_all_task.h b/src/sdk/document/document_search_all_task.h
new file mode 100644
index 0000000..52e8289
--- /dev/null
+++ b/src/sdk/document/document_search_all_task.h
@@ -0,0 +1,117 @@
+// Copyright (c) 2023 dingodb.com, Inc. All Rights Reserved
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef DINGODB_SDK_VECTOR_SEARCH_ALL_TATSK_H_
+#define DINGODB_SDK_VECTOR_SEARCH_ALL_TATSK_H_
+
+#include <cstdint>
+#include <memory>
+#include <unordered_map>
+
+#include "dingosdk/document.h"
+#include "fmt/core.h"
+#include "sdk/client_stub.h"
+#include "sdk/document/document_index.h"
+#include "sdk/document/document_task.h"
+#include "sdk/region.h"
+#include "sdk/rpc/document_service_rpc.h"
+#include "sdk/rpc/store_rpc_controller.h"
+
+namespace dingodb {
+namespace sdk {
+
+class DocumentSearchAllPartTask;
+class DocumentSearchAllTask : public DocumentTask {
+ public:
+  DocumentSearchAllTask(const ClientStub& stub, int64_t index_id, const DocSearchParam& search_param,
+                        DocSearchResult& out_result)
+      : DocumentTask(stub), index_id_(index_id), search_param_(search_param), out_result_(out_result) {}
+
+  ~DocumentSearchAllTask() override = default;
+
+ private:
+  Status Init() override;
+  void DoAsync() override;
+
+  std::string Name() const override { return fmt::format("DocumentSearchAllTask-{}", index_id_); }
+
+  void SubTaskCallback(Status status, DocumentSearchAllPartTask* sub_task);
+
+  const int64_t index_id_;
+  const DocSearchParam& search_param_;
+
+  DocSearchResult& out_result_;
+
+  std::shared_ptr<DocumentIndex> doc_index_;
+
+  std::shared_mutex rw_lock_;
+  std::set<int64_t> next_part_ids_;
+  Status status_;
+
+  std::atomic<int> sub_tasks_count_{0};
+};
+
+class DocumentSearchAllPartTask : public DocumentTask {
+ public:
+  DocumentSearchAllPartTask(const ClientStub& stub, int64_t index_id, int64_t part_id,
+                         const DocSearchParam& search_param)
+      : DocumentTask(stub), index_id_(index_id), part_id_(part_id), search_param_(search_param) {}
+
+  ~DocumentSearchAllPartTask() override = default;
+
+  std::vector<DocWithStore> GetDocSearchResult() {
+    std::shared_lock<std::shared_mutex> r(rw_lock_);
+    return std::move(search_result_);
+  }
+
+ private:
+  friend class DocumentSearchAllTask;
+
+  Status Init() override;
+  void DoAsync() override;
+
+  std::string Name() const override { return fmt::format("DocumentSearchAllPartTask-{}-{}", index_id_, part_id_); }
+
+  void FillDocumentSearchAllRpcRequest(pb::document::DocumentSearchAllRequest* request,
+                                       const std::shared_ptr<Region>& region);
+
+  void DocumentSearchAllRpcCallback(const Status& status, DocumentSearchAllRpc* rpc);
+
+  void DocumentSearchStream(DocumentSearchAllRpc* rpc);
+  void DocumentSearchStreamCallback(const Status& status, DocumentSearchAllRpc* rpc);
+
+  const int64_t index_id_;
+  const int64_t part_id_;
+  const DocSearchParam& search_param_;
+
+  std::shared_ptr<DocumentIndex> doc_index_;
+
+  std::unordered_map<int64_t, std::shared_ptr<Region>> next_batch_region_;
+
+  std::vector<StoreRpcController> controllers_;
+  std::vector<std::unique_ptr<DocumentSearchAllRpc>> rpcs_;
+
+  std::map<int64_t, std::shared_ptr<Region>> region_id_to_region_;
+
+  std::shared_mutex rw_lock_;
+  Status status_;
+  std::vector<DocWithStore> search_result_;
+
+  std::atomic<int> sub_tasks_count_{0};
+};
+
+}  // namespace sdk
+
+}  // namespace dingodb
+#endif  // DINGODB_SDK_VECTOR_SEARCH_ALL_TATSK_H_
\ No newline at end of file
diff --git a/src/sdk/document/document_translater.h b/src/sdk/document/document_translater.h
index b7880de..754585b 100644
--- a/src/sdk/document/document_translater.h
+++ b/src/sdk/document/document_translater.h
@@ -172,6 +172,27 @@ class DocumentTranslater {
     }
   }
 
+  static void FillInternalDocSearchAllParams(pb::common::DocumentSearchParameter* pb, const DocSearchParam& param) {
+    pb->set_query_string(param.query_string);
+    pb->set_use_id_filter(param.use_id_filter);
+    pb->set_query_unlimited(true);
+    if (param.use_id_filter) {
+      for (const auto& id : param.doc_ids) {
+        pb->add_document_ids(id);
+      }
+    }
+
+    for (const std::string& col : param.column_names) {
+      pb->add_column_names(col);
+    }
+
+    pb->set_without_scalar_data(!param.with_scalar_data);
+
+    for (const auto& key : param.selected_keys) {
+      pb->add_selected_keys(key);
+    }
+  }
+
 };  // namespace dingodb
 }  // namespace sdk
 }  // namespace dingodb
diff --git a/src/sdk/rpc/brpc/document_service_rpc.cc b/src/sdk/rpc/brpc/document_service_rpc.cc
index 3ca36e2..1ebd4fc 100644
--- a/src/sdk/rpc/brpc/document_service_rpc.cc
+++ b/src/sdk/rpc/brpc/document_service_rpc.cc
@@ -26,6 +26,7 @@ DEFINE_DOCUMENT_SERVICE_RPC(Hello);
 DEFINE_DOCUMENT_SERVICE_RPC(DocumentAdd);
 DEFINE_DOCUMENT_SERVICE_RPC(DocumentBatchQuery);
 DEFINE_DOCUMENT_SERVICE_RPC(DocumentSearch);
+DEFINE_DOCUMENT_SERVICE_RPC(DocumentSearchAll);
 DEFINE_DOCUMENT_SERVICE_RPC(DocumentDelete);
 DEFINE_DOCUMENT_SERVICE_RPC(DocumentGetBorderId);
 DEFINE_DOCUMENT_SERVICE_RPC(DocumentScanQuery);
diff --git a/src/sdk/rpc/brpc/document_service_rpc.h b/src/sdk/rpc/brpc/document_service_rpc.h
index 5773dfb..8140266 100644
--- a/src/sdk/rpc/brpc/document_service_rpc.h
+++ b/src/sdk/rpc/brpc/document_service_rpc.h
@@ -29,6 +29,7 @@ DECLARE_DOCUMENT_SERVICE_RPC(Hello);
 DECLARE_DOCUMENT_SERVICE_RPC(DocumentAdd);
 DECLARE_DOCUMENT_SERVICE_RPC(DocumentBatchQuery);
 DECLARE_DOCUMENT_SERVICE_RPC(DocumentSearch);
+DECLARE_DOCUMENT_SERVICE_RPC(DocumentSearchAll);
 DECLARE_DOCUMENT_SERVICE_RPC(DocumentDelete);
 DECLARE_DOCUMENT_SERVICE_RPC(DocumentGetBorderId);
 DECLARE_DOCUMENT_SERVICE_RPC(DocumentScanQuery);
diff --git a/src/sdk/rpc/grpc/document_service_rpc.cc b/src/sdk/rpc/grpc/document_service_rpc.cc
index 8af7543..420aa13 100644
--- a/src/sdk/rpc/grpc/document_service_rpc.cc
+++ b/src/sdk/rpc/grpc/document_service_rpc.cc
@@ -27,6 +27,7 @@ DEFINE_DOCUMENT_SERVICE_RPC(Hello);
 DEFINE_DOCUMENT_SERVICE_RPC(DocumentAdd);
 DEFINE_DOCUMENT_SERVICE_RPC(DocumentBatchQuery);
 DEFINE_DOCUMENT_SERVICE_RPC(DocumentSearch);
+DEFINE_DOCUMENT_SERVICE_RPC(DocumentSearchAll);
 DEFINE_DOCUMENT_SERVICE_RPC(DocumentDelete);
 DEFINE_DOCUMENT_SERVICE_RPC(DocumentGetBorderId);
 DEFINE_DOCUMENT_SERVICE_RPC(DocumentScanQuery);
diff --git a/src/sdk/rpc/grpc/document_service_rpc.h b/src/sdk/rpc/grpc/document_service_rpc.h
index 1de5943..646cc6f 100644
--- a/src/sdk/rpc/grpc/document_service_rpc.h
+++ b/src/sdk/rpc/grpc/document_service_rpc.h
@@ -29,6 +29,7 @@ DECLARE_DOCUMENT_SERVICE_RPC(Hello);
 DECLARE_DOCUMENT_SERVICE_RPC(DocumentAdd);
 DECLARE_DOCUMENT_SERVICE_RPC(DocumentBatchQuery);
 DECLARE_DOCUMENT_SERVICE_RPC(DocumentSearch);
+DECLARE_DOCUMENT_SERVICE_RPC(DocumentSearchAll);
 DECLARE_DOCUMENT_SERVICE_RPC(DocumentDelete);
 DECLARE_DOCUMENT_SERVICE_RPC(DocumentGetBorderId);
 DECLARE_DOCUMENT_SERVICE_RPC(DocumentScanQuery);